cognite-neat 0.75.7__py3-none-any.whl → 0.75.8__py3-none-any.whl

cognite/neat/rules/models/rdfpath.py

@@ -4,22 +4,13 @@
 import re
 import sys
 from collections import Counter
-from typing import Literal
+from functools import total_ordering
+from typing import ClassVar, Literal
 
 from pydantic import BaseModel, field_validator
 
 from cognite.neat.rules import exceptions
 
-from ._entity import (
-    CLASS_ID_REGEX,
-    CLASS_ID_REGEX_COMPILED,
-    ENTITY_ID_REGEX,
-    PROPERTY_ID_REGEX,
-    SUFFIX_REGEX,
-    Entity,
-    EntityTypes,
-)
-
 if sys.version_info >= (3, 11):
     from enum import StrEnum
     from typing import Self
@@ -40,6 +31,26 @@ class Lookup(StrEnum):
     value = "value"  # type: ignore
 
 
+class EntityTypes(StrEnum):
+    class_ = "class"
+    property_ = "property"
+    undefined = "undefined"
+
+
+# FOR PARSING STRINGS:
+PREFIX_REGEX = r"[a-zA-Z]+[a-zA-Z0-9-_.]*[a-zA-Z0-9]+"
+SUFFIX_REGEX = r"[a-zA-Z0-9-_.]+[a-zA-Z0-9]|[-_.]*[a-zA-Z0-9]+"
+VERSION_REGEX = r"[a-zA-Z0-9]([.a-zA-Z0-9_-]{0,41}[a-zA-Z0-9])?"
+
+ENTITY_ID_REGEX = rf"{PREFIX_REGEX}:({SUFFIX_REGEX})"
+ENTITY_ID_REGEX_COMPILED = re.compile(rf"^(?P<prefix>{PREFIX_REGEX}):(?P<suffix>{SUFFIX_REGEX})$")
+VERSIONED_ENTITY_REGEX_COMPILED = re.compile(
+    rf"^(?P<prefix>{PREFIX_REGEX}):(?P<suffix>{SUFFIX_REGEX})\(version=(?P<version>{VERSION_REGEX})\)$"
+)
+CLASS_ID_REGEX = rf"(?P<{EntityTypes.class_}>{ENTITY_ID_REGEX})"
+CLASS_ID_REGEX_COMPILED = re.compile(rf"^{CLASS_ID_REGEX}$")
+PROPERTY_ID_REGEX = rf"\((?P<{EntityTypes.property_}>{ENTITY_ID_REGEX})\)"
+
 # traversal direction
 DIRECTION_REGEX = r"(?P<direction>(->|<-))"
 
@@ -73,6 +84,95 @@ TABLE_REGEX_COMPILED = re.compile(
 StepDirection = Literal["source", "target", "origin"]
 _direction_by_symbol: dict[str, StepDirection] = {"->": "target", "<-": "source"}
 
+Undefined = type(object())
+Unknown = type(object())
+
+
+# mypy does not like the sentinel value, and it is not possible to ignore only the line with it below.
+# so we ignore all errors beyond this point.
+# mypy: ignore-errors
+@total_ordering
+class Entity(BaseModel, arbitrary_types_allowed=True):
+    """Entity is a class or property in OWL/RDF sense."""
+
+    type_: ClassVar[EntityTypes] = EntityTypes.undefined
+    prefix: str | Undefined = Undefined
+    suffix: str | Unknown
+    version: str | None = None
+    name: str | None = None
+    description: str | None = None
+
+    def __lt__(self, other: object) -> bool:
+        if type(self) is not type(other) or not isinstance(other, Entity):
+            return NotImplemented
+        return self.versioned_id < other.versioned_id
+
+    def __eq__(self, other: object) -> bool:
+        if type(self) is not type(other) or not isinstance(other, Entity):
+            return NotImplemented
+        return self.versioned_id == other.versioned_id
+
+    def __hash__(self) -> int:
+        return hash(self.versioned_id)
+
+    def as_non_versioned_entity(self) -> Self:
+        return self.from_string(f"{self.prefix}:{self.suffix}")
+
+    @property
+    def id(self) -> str:
+        if self.suffix is Unknown:
+            return "#N/A"
+        elif self.prefix is Undefined:
+            return self.suffix
+        else:
+            return f"{self.prefix}:{self.suffix}"
+
+    @property
+    def versioned_id(self) -> str:
+        if self.version is None:
+            return self.id
+        else:
+            return f"{self.id}(version={self.version})"
+
+    @property
+    def space(self) -> str:
+        """Returns entity space in CDF."""
+        return self.prefix
+
+    @property
+    def external_id(self) -> str:
+        """Returns entity external id in CDF."""
+        return self.suffix
+
+    def __repr__(self):
+        return self.versioned_id
+
+    def __str__(self):
+        return self.versioned_id
+
+    @classmethod
+    def from_string(cls, entity_string: str, base_prefix: str | None = None) -> Self:
+        if entity_string == "#N/A":
+            return cls(prefix=Undefined, suffix=Unknown)
+        elif result := VERSIONED_ENTITY_REGEX_COMPILED.match(entity_string):
+            return cls(
+                prefix=result.group("prefix"),
+                suffix=result.group("suffix"),
+                version=result.group("version"),
+            )
+        elif result := ENTITY_ID_REGEX_COMPILED.match(entity_string):
+            return cls(prefix=result.group("prefix"), suffix=result.group("suffix"))
+        elif base_prefix and re.match(SUFFIX_REGEX, entity_string) and re.match(PREFIX_REGEX, base_prefix):
+            return cls(prefix=base_prefix, suffix=entity_string)
+        else:
+            raise ValueError(f"{cls.__name__} is expected to be prefix:suffix, got {entity_string}")
+
+    @classmethod
+    def from_list(cls, entity_strings: list[str], base_prefix: str | None = None) -> list[Self]:
+        return [
+            cls.from_string(entity_string=entity_string, base_prefix=base_prefix) for entity_string in entity_strings
+        ]
+
 
 class Step(BaseModel):
     class_: Entity

cognite/neat/rules/models/rules/_base.py

@@ -27,7 +27,7 @@ from pydantic import (
 )
 from pydantic.fields import FieldInfo
 
-from cognite.neat.rules.models.rules._types import ClassType
+from cognite.neat.rules.models.entities import ClassEntity
 
 if sys.version_info >= (3, 11):
     from enum import StrEnum
@@ -274,7 +274,7 @@ class BaseRules(RuleModel):
 
 # An sheet entity is either a class or a property.
 class SheetEntity(RuleModel):
-    class_: ClassType = Field(alias="Class")
+    class_: ClassEntity = Field(alias="Class")
     name: str | None = Field(alias="Name", default=None)
     description: str | None = Field(alias="Description", default=None)