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

cognite/neat/rules/models/rules/_information_rules.py

@@ -13,6 +13,25 @@ from rdflib import Namespace
 import cognite.neat.rules.issues.spreadsheet
 from cognite.neat.constants import PREFIXES
 from cognite.neat.rules import exceptions
+from cognite.neat.rules.models.data_types import DataType
+from cognite.neat.rules.models.entities import (
+    ClassEntity,
+    ContainerEntity,
+    DMSUnknownEntity,
+    Entity,
+    EntityTypes,
+    ParentClassEntity,
+    ParentEntityList,
+    ReferenceEntity,
+    Undefined,
+    Unknown,
+    UnknownEntity,
+    URLEntity,
+    ViewEntity,
+    ViewPropertyEntity,
+    _UndefinedType,
+    _UnknownType,
+)
 from cognite.neat.rules.models.rdfpath import (
     AllReferences,
     Hop,
@@ -37,26 +56,12 @@ from ._base import (
 )
 from ._domain_rules import DomainRules
 from ._types import (
-    ClassEntity,
-    ContainerEntity,
-    Entity,
-    EntityTypes,
     NamespaceType,
-    ParentClassEntity,
-    ParentClassType,
     PrefixType,
     PropertyType,
-    ReferenceEntity,
-    ReferenceType,
-    SemanticValueType,
     StrListType,
-    Undefined,
     VersionType,
-    ViewEntity,
-    ViewPropEntity,
-    XSDValueType,
 )
-from ._types._base import Unknown
 
 if TYPE_CHECKING:
     from ._dms_architect_rules import DMSProperty, DMSRules
@@ -118,8 +123,8 @@ class InformationClass(SheetEntity):
         match_type: The match type of the resource being described and the source entity.
     """
 
-    parent: ParentClassType = Field(alias="Parent Class", default=None)
-    reference: ReferenceType = Field(alias="Reference", default=None)
+    parent: ParentEntityList | None = Field(alias="Parent Class", default=None)
+    reference: URLEntity | ReferenceEntity | None = Field(alias="Reference", default=None, union_mode="left_to_right")
     match_type: MatchType | None = Field(alias="Match Type", default=None)
     comment: str | None = Field(alias="Comment", default=None)
 
@@ -146,11 +151,11 @@ class InformationProperty(SheetEntity):
     """
 
     property_: PropertyType = Field(alias="Property")
-    value_type: SemanticValueType = Field(alias="Value Type")
+    value_type: DataType | ClassEntity | UnknownEntity = Field(alias="Value Type", union_mode="left_to_right")
     min_count: int | None = Field(alias="Min Count", default=None)
     max_count: int | float | None = Field(alias="Max Count", default=None)
     default: Any | None = Field(alias="Default", default=None)
-    reference: ReferenceType = Field(alias="Reference", default=None)
+    reference: URLEntity | ReferenceEntity | None = Field(alias="Reference", default=None, union_mode="left_to_right")
     match_type: MatchType | None = Field(alias="Match Type", default=None)
     rule_type: str | TransformationRuleType | None = Field(alias="Rule Type", default=None)
     rule: str | AllReferences | SingleProperty | Hop | RawLookup | SPARQLQuery | Traversal | None = Field(
@@ -223,9 +228,9 @@ class InformationProperty(SheetEntity):
     @property
     def type_(self) -> EntityTypes:
         """Type of property based on value type. Either data (attribute) or object (edge) property."""
-        if self.value_type.type_ == EntityTypes.xsd_value_type:
+        if isinstance(self.value_type, DataType):
             return EntityTypes.data_property
-        elif self.value_type.type_ == EntityTypes.class_:
+        elif isinstance(self.value_type, ClassEntity):
             return EntityTypes.object_property
         else:
             return EntityTypes.undefined
@@ -258,7 +263,7 @@ class InformationRules(RuleModel):
     def update_entities_prefix(self) -> Self:
         # update expected_value_types
         for property_ in self.properties:
-            if property_.value_type.prefix is Undefined and property_.value_type.suffix is not Unknown:
+            if isinstance(property_.value_type, ClassEntity) and property_.value_type.prefix is Undefined:
                 property_.value_type.prefix = self.metadata.prefix
             if property_.class_.prefix is Undefined:
                 property_.class_.prefix = self.metadata.prefix
@@ -267,7 +272,7 @@ class InformationRules(RuleModel):
         for class_ in self.classes:
             if class_.parent:
                 for parent in cast(list[ParentClassEntity], class_.parent):
-                    if parent.prefix is Undefined:
+                    if not isinstance(parent.prefix, str):
                         parent.prefix = self.metadata.prefix
             if class_.class_.prefix is Undefined:
                 class_.class_.prefix = self.metadata.prefix
@@ -279,15 +284,15 @@ class InformationRules(RuleModel):
         # update expected_value_types
 
         if self.metadata.schema_ == SchemaCompleteness.complete:
-            defined_classes = {class_.class_.versioned_id for class_ in self.classes}
-            referred_classes = {property_.class_.versioned_id for property_ in self.properties} | {
-                parent.versioned_id for class_ in self.classes for parent in class_.parent or []
+            defined_classes = {str(class_.class_) for class_ in self.classes}
+            referred_classes = {str(property_.class_) for property_ in self.properties} | {
+                str(parent) for class_ in self.classes for parent in class_.parent or []
             }
             referred_types = {
-                property_.value_type.versioned_id
+                str(property_.value_type)
                 for property_ in self.properties
-                if property_.type_ == EntityTypes.object_property
-                and not (isinstance(property_.value_type, Entity) and property_.value_type.suffix is Unknown)
+                if isinstance(property_.value_type, Entity)
+                and not isinstance(property_.value_type.suffix, _UnknownType)
             }
             if not referred_classes.issubset(defined_classes) or not referred_types.issubset(defined_classes):
                 missing_classes = referred_classes.difference(defined_classes).union(
@@ -300,7 +305,7 @@ class InformationRules(RuleModel):
     @model_validator(mode="after")
     def validate_class_has_properties_or_parent(self) -> Self:
         defined_classes = {class_.class_ for class_ in self.classes if class_.reference is None}
-        referred_classes = {property_.class_ for property_ in self.properties}
+        referred_classes = {property_.class_ for property_ in self.properties if property_.class_.suffix is not Unknown}
         has_parent_classes = {class_.class_ for class_ in self.classes if class_.parent}
         missing_classes = defined_classes.difference(referred_classes) - has_parent_classes
         if missing_classes:
@@ -357,15 +362,21 @@ class InformationRules(RuleModel):
         new_self = self.model_copy(deep=True)
         for prop in new_self.properties:
             prop.reference = ReferenceEntity(
-                prefix=prop.class_.prefix,
+                prefix=prop.class_.prefix
+                if not isinstance(prop.class_.prefix, _UndefinedType)
+                else self.metadata.prefix,
                 suffix=prop.class_.suffix,
                 version=prop.class_.version,
-                property_=prop.property_,
+                property=prop.property_,
             )
 
         for cls_ in new_self.classes:
             cls_.reference = ReferenceEntity(
-                prefix=cls_.class_.prefix, suffix=cls_.class_.suffix, version=cls_.class_.version
+                prefix=cls_.class_.prefix
+                if not isinstance(cls_.class_.prefix, _UndefinedType)
+                else self.metadata.prefix,
+                suffix=cls_.class_.suffix,
+                version=cls_.class_.version,
             )
 
         return new_self
@@ -382,7 +393,8 @@ class _InformationRulesConverter:
         from ._dms_architect_rules import DMSContainer, DMSMetadata, DMSProperty, DMSRules, DMSView
 
         info_metadata = self.information.metadata
-
+        default_version = info_metadata.version
+        default_space = self._to_space(info_metadata.prefix)
         space = self._to_space(info_metadata.prefix)
 
         metadata = DMSMetadata(
@@ -398,13 +410,15 @@ class _InformationRulesConverter:
 
         properties_by_class: dict[str, list[DMSProperty]] = defaultdict(list)
         for prop in self.information.properties:
-            properties_by_class[prop.class_.versioned_id].append(self._as_dms_property(prop))
+            properties_by_class[prop.class_.versioned_id].append(
+                self._as_dms_property(prop, default_space, default_version)
+            )
 
         views: list[DMSView] = [
             DMSView(
                 class_=cls_.class_,
                 name=cls_.name,
-                view=ViewPropEntity(prefix=cls_.class_.prefix, suffix=cls_.class_.suffix, version=cls_.class_.version),
+                view=cls_.class_.as_view_entity(default_space, default_version),
                 description=cls_.description,
                 reference=cls_.reference,
                 implements=self._get_view_implements(cls_, info_metadata),
@@ -416,7 +430,7 @@ class _InformationRulesConverter:
         for class_ in self.information.classes:
             properties: list[DMSProperty] = properties_by_class.get(class_.class_.versioned_id, [])
             if not properties or all(
-                isinstance(prop.value_type, ViewPropEntity) and prop.relation != "direct" for prop in properties
+                isinstance(prop.value_type, ViewPropertyEntity) and prop.relation != "direct" for prop in properties
             ):
                 classes_without_properties.add(class_.class_.versioned_id)
 
@@ -428,13 +442,10 @@ class _InformationRulesConverter:
                 DMSContainer(
                     class_=class_.class_,
                     name=class_.name,
-                    container=ContainerEntity(prefix=class_.class_.prefix, suffix=class_.class_.suffix),
+                    container=class_.class_.as_container_entity(default_space),
                     description=class_.description,
                     constraint=[
-                        ContainerEntity(
-                            prefix=parent.prefix,
-                            suffix=parent.suffix,
-                        )
+                        parent.as_container_entity(default_space)
                         for parent in class_.parent or []
                         if parent.versioned_id not in classes_without_properties
                     ]
@@ -453,23 +464,24 @@ class _InformationRulesConverter:
         )
 
     @classmethod
-    def _as_dms_property(cls, prop: InformationProperty) -> "DMSProperty":
+    def _as_dms_property(cls, prop: InformationProperty, default_space: str, default_version: str) -> "DMSProperty":
         """This creates the first"""
 
         from ._dms_architect_rules import DMSProperty
 
         # returns property type, which can be ObjectProperty or DatatypeProperty
-        if isinstance(prop.value_type, XSDValueType):
-            value_type = cast(XSDValueType, prop.value_type).dms._type.casefold()  # type: ignore[attr-defined]
+        value_type: DataType | ViewEntity | ViewPropertyEntity | DMSUnknownEntity
+        if isinstance(prop.value_type, DataType):
+            value_type = prop.value_type
+        elif isinstance(prop.value_type, UnknownEntity):
+            value_type = DMSUnknownEntity()
         elif isinstance(prop.value_type, ClassEntity):
-            value_type = ViewPropEntity(
-                prefix=prop.value_type.prefix, suffix=prop.value_type.suffix, version=prop.value_type.version
-            )
+            value_type = prop.value_type.as_view_entity(default_space, default_version)
         else:
             raise ValueError(f"Unsupported value type: {prop.value_type.type_}")
 
         relation: Literal["direct", "multiedge"] | None = None
-        if isinstance(value_type, ViewPropEntity):
+        if isinstance(value_type, ViewEntity | ViewPropertyEntity):
             relation = "multiedge" if prop.is_list else "direct"
 
         container: ContainerEntity | None = None
@@ -481,9 +493,9 @@ class _InformationRulesConverter:
             nullable = None
         elif relation == "direct":
             nullable = True
-            container, container_property = cls._get_container(prop)
+            container, container_property = cls._get_container(prop, default_space)
         else:
-            container, container_property = cls._get_container(prop)
+            container, container_property = cls._get_container(prop, default_space)
 
         return DMSProperty(
             class_=prop.class_,
@@ -497,7 +509,7 @@ class _InformationRulesConverter:
             reference=prop.reference,
             container=container,
             container_property=container_property,
-            view=ViewPropEntity(prefix=prop.class_.prefix, suffix=prop.class_.suffix, version=prop.class_.version),
+            view=prop.class_.as_view_entity(default_space, default_version),
             view_property=prop.property_,
         )
 
@@ -513,29 +525,24 @@ class _InformationRulesConverter:
         return prefix
 
     @classmethod
-    def _get_container(cls, prop: InformationProperty) -> tuple[ContainerEntity, str]:
+    def _get_container(cls, prop: InformationProperty, default_space: str) -> tuple[ContainerEntity, str]:
         if isinstance(prop.reference, ReferenceEntity):
             return (
-                ContainerEntity(prefix=prop.reference.prefix, suffix=prop.reference.suffix),
+                prop.reference.as_container_entity(default_space),
                 prop.reference.property_ or prop.property_,
             )
         else:
-            return ContainerEntity(prefix=prop.class_.prefix, suffix=prop.class_.suffix), prop.property_
+            return prop.class_.as_container_entity(default_space), prop.property_
 
     @classmethod
     def _get_view_implements(cls, cls_: InformationClass, metadata: InformationMetadata) -> list[ViewEntity]:
         if isinstance(cls_.reference, ReferenceEntity) and cls_.reference.prefix != metadata.prefix:
             # We use the reference for implements if it is in a different namespace
             implements = [
-                ViewEntity(prefix=cls_.reference.prefix, suffix=cls_.reference.suffix, version=cls_.reference.version)
+                cls_.reference.as_view_entity(metadata.prefix, metadata.version),
             ]
         else:
             implements = []
 
-        implements.extend(
-            [
-                ViewEntity(prefix=parent.prefix, suffix=parent.suffix, version=parent.version)
-                for parent in cls_.parent or []
-            ]
-        )
+        implements.extend([parent.as_view_entity(metadata.prefix, metadata.version) for parent in cls_.parent or []])
         return implements

cognite/neat/rules/models/rules/_types/__init__.py

@@ -1,66 +1,19 @@
-from ._base import (
-    ClassEntity,
-    ContainerEntity,
-    DataModelEntity,
-    Entity,
-    EntityTypes,
-    ParentClassEntity,
-    ReferenceEntity,
-    Undefined,
-    Unknown,
-    ViewEntity,
-    ViewPropEntity,
-)
 from ._field import (
-    CdfValueType,
-    ClassType,
-    ContainerListType,
-    ContainerType,
     ExternalIdType,
     NamespaceType,
-    ParentClassType,
     PrefixType,
     PropertyType,
-    ReferenceType,
-    SemanticValueType,
     StrListType,
     StrOrListType,
     VersionType,
-    ViewListType,
-    ViewType,
 )
-from ._value import DMS_VALUE_TYPE_MAPPINGS, XSD_VALUE_TYPE_MAPPINGS, DMSValueType, XSDValueType
 
 __all__ = [
-    "Undefined",
-    "Unknown",
-    "Entity",
-    "EntityTypes",
-    "ClassEntity",
-    "ParentClassEntity",
-    "ContainerEntity",
-    "ViewEntity",
-    "ViewPropEntity",
-    "ReferenceEntity",
-    "DataModelEntity",
-    "XSDValueType",
-    "DMSValueType",
-    "XSD_VALUE_TYPE_MAPPINGS",
-    "DMS_VALUE_TYPE_MAPPINGS",
     "StrOrListType",
     "StrListType",
     "NamespaceType",
     "PrefixType",
     "ExternalIdType",
     "VersionType",
-    "ParentClassType",
-    "ClassType",
     "PropertyType",
-    "SemanticValueType",
-    "CdfValueType",
-    "ReferenceType",
-    "ContainerType",
-    "ViewType",
-    "ContainerListType",
-    "ViewListType",
 ]

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

@@ -1,51 +1,6 @@
-import re
-import sys
-from typing import Any, ClassVar, Literal, cast, overload
-
-from cognite.client.data_classes.data_modeling import ContainerId, DataModelId, PropertyId, ViewId
-
-from cognite.neat.rules.models._entity import (
-    ENTITY_ID_REGEX_COMPILED,
-    PREFIX_REGEX,
-    PROPERTY_REGEX,
-    SUFFIX_REGEX,
-    VERSION_REGEX,
-    VERSIONED_ENTITY_REGEX_COMPILED,
-    Entity,
-    EntityTypes,
-    Undefined,
-    Unknown,
-)
-from cognite.neat.rules.models.rdfpath import (
-    SINGLE_PROPERTY_REGEX_COMPILED,
-    AllReferences,
-    RDFPath,
-    SingleProperty,
-    TransformationRuleType,
-    parse_rule,
-)
-
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
-
-# mypy: ignore-errors
-VERSION_ID_REGEX = rf"\(version=(?P<version>{VERSION_REGEX})\)"
-
-
-PROPERTY_ENTITY_REGEX_COMPILED = re.compile(
-    rf"^((?P<prefix>{PREFIX_REGEX}):)?(?P<suffix>{SUFFIX_REGEX})"
-    rf"\((version=(?P<version>{VERSION_REGEX}), )?property=(?P<property>{PROPERTY_REGEX})\)$"
-)
-
-
 MORE_THAN_ONE_NONE_ALPHANUMERIC_REGEX = r"([_-]{2,})"
 PREFIX_COMPLIANCE_REGEX = r"^([a-zA-Z]+)([a-zA-Z0-9]*[_-]{0,1}[a-zA-Z0-9_-]*)([a-zA-Z0-9]*)$"
-DATA_MODEL_ID_COMPLIANCE_REGEX = r"^[a-zA-Z]([a-zA-Z0-9_]{0,253}[a-zA-Z0-9])?$"
-CDF_SPACE_COMPLIANCE_REGEX = (
-    r"(?!^(space|cdf|dms|pg3|shared|system|node|edge)$)(^[a-zA-Z][a-zA-Z0-9_-]{0,41}[a-zA-Z0-9]?$)"
-)
+
 VIEW_ID_COMPLIANCE_REGEX = (
     r"(?!^(Query|Mutation|Subscription|String|Int32|Int64|Int|Float32|Float64|Float|"
     r"Timestamp|JSONObject|Date|Numeric|Boolean|PageInfo|File|Sequence|TimeSeries)$)"
@@ -59,266 +14,3 @@ DMS_PROPERTY_ID_COMPLIANCE_REGEX = (
 CLASS_ID_COMPLIANCE_REGEX = r"(?!^(Class|class)$)(^[a-zA-Z][a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
 PROPERTY_ID_COMPLIANCE_REGEX = r"^(\*)|(?!^(Property|property)$)(^[a-zA-Z][a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
 VERSION_COMPLIANCE_REGEX = r"^[a-zA-Z0-9]([.a-zA-Z0-9_-]{0,41}[a-zA-Z0-9])?$"
-
-
-class ContainerEntity(Entity):
-    type_: ClassVar[EntityTypes] = EntityTypes.container
-
-    @classmethod
-    def from_raw(cls, value: Any) -> "ContainerEntity":
-        if not value:
-            return ContainerEntity(prefix=Undefined, suffix=value)
-        elif isinstance(value, ContainerEntity):
-            return value
-
-        if ENTITY_ID_REGEX_COMPILED.match(value):
-            return ContainerEntity.from_string(entity_string=value)
-        else:
-            return ContainerEntity(prefix=Undefined, suffix=value)
-
-    @classmethod
-    def from_id(cls, container_id: ContainerId) -> "ContainerEntity":
-        return ContainerEntity(prefix=container_id.space, suffix=container_id.external_id)
-
-    def as_id(self, default_space: str | None) -> ContainerId:
-        if self.space is Undefined and default_space is None:
-            raise ValueError("Space is Undefined! Set default_space!")
-
-        if self.space is Undefined:
-            return ContainerId(space=cast(str, default_space), external_id=self.external_id)
-        else:
-            return ContainerId(space=self.space, external_id=self.external_id)
-
-
-class ViewEntity(Entity):
-    type_: ClassVar[EntityTypes] = EntityTypes.view
-
-    @classmethod
-    def from_raw(cls, value: Any) -> "ViewEntity":
-        if not value:
-            return ViewEntity(prefix=Undefined, suffix=value)
-        elif isinstance(value, ViewEntity):
-            return value
-
-        if ENTITY_ID_REGEX_COMPILED.match(value) or VERSIONED_ENTITY_REGEX_COMPILED.match(value):
-            return cls.from_string(entity_string=value)
-        else:
-            return cls(prefix=Undefined, suffix=value)
-
-    @classmethod
-    def from_id(cls, view_id: ViewId) -> Self:
-        return cls(prefix=view_id.space, suffix=view_id.external_id, version=view_id.version)
-
-    @overload
-    def as_id(
-        self,
-        allow_none: Literal[False] = False,
-        default_space: str | None = None,
-        default_version: str | None = None,
-    ) -> ViewId:
-        ...
-
-    @overload
-    def as_id(
-        self,
-        allow_none: Literal[True],
-        default_space: str | None = None,
-        default_version: str | None = None,
-    ) -> ViewId | None:
-        ...
-
-    def as_id(
-        self,
-        allow_none: bool = False,
-        default_space: str | None = None,
-        default_version: str | None = None,
-    ) -> ViewId | None:
-        if self.suffix is Unknown and allow_none:
-            return None
-        elif self.suffix is Unknown:
-            raise ValueError("suffix is Unknown and cannot be converted to ViewId")
-        space = default_space if self.space is Undefined else self.space
-        version = self.version or default_version
-
-        if space is None or space is Undefined:
-            raise ValueError("space is required")
-        if version is None:
-            raise ValueError("version is required")
-        return ViewId(space=space, external_id=self.external_id, version=version)
-
-
-class ViewPropEntity(ViewEntity):
-    type_: ClassVar[EntityTypes] = EntityTypes.view_prop
-    property_: str | None = None
-
-    @classmethod
-    def from_raw(cls, value: Any) -> "ViewPropEntity":
-        if not value:
-            return ViewPropEntity(prefix=Undefined, suffix=value)
-        elif isinstance(value, ViewPropEntity):
-            return value
-        elif isinstance(value, ViewEntity):
-            return cls(prefix=value.prefix, suffix=value.suffix, version=value.version)
-
-        if result := PROPERTY_ENTITY_REGEX_COMPILED.match(value):
-            return cls(
-                prefix=result.group("prefix") or Undefined,
-                suffix=result.group("suffix"),
-                version=result.group("version"),
-                property_=result.group("property"),
-            )
-        elif ENTITY_ID_REGEX_COMPILED.match(value) or VERSIONED_ENTITY_REGEX_COMPILED.match(value):
-            return cls.from_string(entity_string=value)
-        else:
-            return cls(prefix=Undefined, suffix=value)
-
-    @classmethod
-    def from_prop_id(cls, prop_id: PropertyId) -> "ViewPropEntity":
-        return ViewPropEntity(
-            prefix=prop_id.source.space,
-            suffix=prop_id.source.external_id,
-            version=cast(ViewId, prop_id.source).version,
-            property_=prop_id.property,
-        )
-
-    def as_prop_id(self, default_space: str | None = None, default_version: str | None = None) -> PropertyId:
-        if self.property_ is None:
-            raise ValueError("property is required to create PropertyId")
-        return PropertyId(source=self.as_id(False, default_space, default_version), property=self.property_)
-
-    @property
-    def versioned_id(self) -> str:
-        if self.version is None and self.property_ is None:
-            output = self.id
-        elif self.version is None:
-            output = f"{self.id}(property={self.property_})"
-        elif self.property_ is None:
-            output = f"{self.id}(version={self.version})"
-        else:
-            output = f"{self.id}(version={self.version}, property={self.property_})"
-        return output
-
-
-class DataModelEntity(Entity):
-    type_: ClassVar[EntityTypes] = EntityTypes.datamodel
-
-    @classmethod
-    def from_raw(cls, value: Any) -> "DataModelEntity":
-        if not value:
-            return DataModelEntity(prefix=Undefined, suffix=value)
-        elif isinstance(value, DataModelEntity):
-            return value
-
-        if ENTITY_ID_REGEX_COMPILED.match(value) or VERSIONED_ENTITY_REGEX_COMPILED.match(value):
-            return DataModelEntity.from_string(entity_string=value)
-        else:
-            return DataModelEntity(prefix=Undefined, suffix=value)
-
-    @classmethod
-    def from_id(cls, data_model_id: DataModelId) -> "DataModelEntity":
-        return DataModelEntity(
-            prefix=data_model_id.space, suffix=data_model_id.external_id, version=data_model_id.version
-        )
-
-    def as_id(self, default_space: str | None = None, default_version: str | None = None) -> DataModelId:
-        space = default_space if self.space is Undefined else self.space
-        version = self.version or default_version
-
-        if space is None or space is Undefined:
-            raise ValueError("space is required")
-
-        return DataModelId(space=space, external_id=self.external_id, version=version)
-
-
-class ClassEntity(Entity):
-    type_: ClassVar[EntityTypes] = EntityTypes.class_
-
-    @classmethod
-    def from_raw(cls, value: Any) -> Self:
-        if not value:
-            return cls(prefix=Undefined, suffix=value)
-        elif isinstance(value, cls):
-            return value
-
-        if ENTITY_ID_REGEX_COMPILED.match(value) or VERSIONED_ENTITY_REGEX_COMPILED.match(value):
-            return cls.from_string(entity_string=value)
-        else:
-            return cls(prefix=Undefined, suffix=value)
-
-    @classmethod
-    def from_view_id(cls, view_id: ViewId) -> Self:
-        return cls(prefix=view_id.space, suffix=view_id.external_id, version=view_id.version)
-
-    @property
-    def view_id(self) -> ViewId:
-        return ViewId(space=self.space, external_id=self.external_id, version=self.version)
-
-
-class ParentClassEntity(ClassEntity):
-    type_: ClassVar[EntityTypes] = EntityTypes.parent_class
-
-    @classmethod
-    def from_raw(cls, value: Any) -> Self:
-        if isinstance(value, ClassEntity):
-            return cls(prefix=value.prefix, suffix=value.suffix, version=value.version)
-        return super().from_raw(value)
-
-    def as_class_entity(self) -> ClassEntity:
-        return ClassEntity(prefix=self.prefix, suffix=self.suffix, version=self.version)
-
-
-class ReferenceEntity(ViewPropEntity):
-    type_: ClassVar[EntityTypes] = EntityTypes.reference_entity
-
-    @classmethod
-    def from_raw(cls, value: Any) -> "ReferenceEntity":
-        if not value:
-            return ReferenceEntity(prefix=Undefined, suffix=value)
-        elif isinstance(value, ReferenceEntity):
-            return value
-        elif isinstance(value, ViewEntity):
-            return cls(prefix=value.prefix, suffix=value.suffix, version=value.version)
-
-        if result := PROPERTY_ENTITY_REGEX_COMPILED.match(value):
-            return cls(
-                prefix=result.group("prefix") or Undefined,
-                suffix=result.group("suffix"),
-                version=result.group("version"),
-                property_=result.group("property"),
-            )
-        elif ENTITY_ID_REGEX_COMPILED.match(value) or VERSIONED_ENTITY_REGEX_COMPILED.match(value):
-            return cls.from_string(entity_string=value)
-        elif result := SINGLE_PROPERTY_REGEX_COMPILED.match(value):
-            return cls.from_rdfpath(value)
-        else:
-            return cls(prefix=Undefined, suffix=value)
-
-    @classmethod
-    def from_rdfpath(cls, rdfpath: RDFPath | str) -> "ReferenceEntity":
-        if isinstance(rdfpath, str):
-            rdfpath = parse_rule(rdfpath, TransformationRuleType.rdfpath)
-
-        if isinstance(rdfpath.traversal, AllReferences):
-            return cls(prefix=rdfpath.traversal.class_.prefix, suffix=rdfpath.traversal.class_.suffix)
-        elif isinstance(rdfpath.traversal, SingleProperty):
-            return cls(
-                prefix=rdfpath.traversal.class_.prefix,
-                suffix=rdfpath.traversal.class_.suffix,
-                property_=rdfpath.traversal.property.suffix,
-            )
-        else:
-            raise ValueError(f"Invalid RDFPath traversal type: {rdfpath.traversal}")
-
-    def as_rdfpath(self, default_prefix: str | None = None) -> RDFPath:
-        prefix = self.prefix if self.prefix is not Undefined else default_prefix
-
-        if prefix is None:
-            raise ValueError("prefix is required")
-
-        if self.property_:
-            return parse_rule(f"{prefix}:{self.suffix}({self.prefix}:{self.property_})", TransformationRuleType.rdfpath)
-        else:
-            return parse_rule(f"{self.prefix}:{self.suffix}", TransformationRuleType.rdfpath)
-
-    def as_class_entity(self) -> ClassEntity:
-        return ClassEntity(prefix=self.prefix, suffix=self.suffix, version=self.version)