cognite-neat 0.121.1__py3-none-any.whl → 0.121.2__py3-none-any.whl

cognite/neat/core/_data_model/models/conceptual/_verified.py

@@ -18,7 +18,7 @@ from cognite.neat.core._data_model.models._base_verified import (
     SheetRow,
 )
 from cognite.neat.core._data_model.models._types import (
-    ClassEntityType,
+    ConceptEntityType,
     ConceptualPropertyType,
     MultiValueTypeType,
     URIRefType,
@@ -27,15 +27,15 @@ from cognite.neat.core._data_model.models._types import (
 # NeatIdType,
 from cognite.neat.core._data_model.models.data_types import DataType
 from cognite.neat.core._data_model.models.entities import (
-    ClassEntity,
     ClassEntityList,
-    Entity,
+    ConceptEntity,
+    ConceptualEntity,
     UnknownEntity,
 )
 from cognite.neat.core._issues.errors import PropertyDefinitionError
 
 if TYPE_CHECKING:
-    from cognite.neat.core._data_model.models import DMSRules
+    from cognite.neat.core._data_model.models import PhysicalDataModel
 
 
 class ConceptualMetadata(BaseVerifiedMetadata):
@@ -52,18 +52,19 @@ def _get_metadata(context: Any) -> ConceptualMetadata | None:
     return None
 
 
-class ConceptualClass(SheetRow):
+class Concept(SheetRow):
     """
-    Class is a category of things that share a common set of attributes and relationships.
+    Concept is a category of things that share a common set of attributes and relationships.
 
     Args:
-        class_: The class ID of the class.
+        concept: An ID of the concept.
         description: A description of the class.
         implements: Which classes the current class implements.
     """
 
-    class_: ClassEntityType = Field(
-        alias="Class", description="Class id being defined, use strongly advise `PascalCase` usage."
+    concept: ConceptEntityType = Field(
+        alias="Concept",
+        description="Concept id being defined, use strongly advise `PascalCase` usage.",
     )
     name: str | None = Field(alias="Name", default=None, description="Human readable name of the class.")
     description: str | None = Field(alias="Description", default=None, description="Short description of the class.")
@@ -83,11 +84,11 @@ class ConceptualClass(SheetRow):
     )
 
     def _identifier(self) -> tuple[Hashable, ...]:
-        return (self.class_,)
+        return (self.concept,)
 
-    @field_serializer("class_", when_used="unless-none")
+    @field_serializer("concept", when_used="unless-none")
     def remove_default_prefix(self, value: Any, info: SerializationInfo) -> str:
-        if (metadata := _get_metadata(info.context)) and isinstance(value, Entity):
+        if (metadata := _get_metadata(info.context)) and isinstance(value, ConceptualEntity):
             return value.dump(prefix=metadata.prefix, version=metadata.version)
         return str(value)
 
@@ -96,22 +97,22 @@ class ConceptualClass(SheetRow):
         if isinstance(value, list) and (metadata := _get_metadata(info.context)):
             return ",".join(
                 (
-                    class_.dump(prefix=metadata.prefix, version=metadata.version)
-                    if isinstance(class_, Entity)
-                    else str(class_)
+                    concept.dump(prefix=metadata.prefix, version=metadata.version)
+                    if isinstance(concept, ConceptualEntity)
+                    else str(concept)
                 )
-                for class_ in value
+                for concept in value
             )
         return ",".join(str(value) for value in value)
 
 
 class ConceptualProperty(SheetRow):
     """
-    A property is a characteristic of a class. It is a named attribute of a class that describes a range of values
-    or a relationship to another class.
+    A property is a characteristic of a concept. It is a named attribute of a concept
+    that describes a range of values or a relationship to another concept.
 
     Args:
-        class_: Class ID to which property belongs
+        concept: Concept ID to which property belongs
         property_: Property ID of the property
         name: Property name.
         value_type: Type of value property will hold (data or link to another class)
@@ -122,8 +123,9 @@ class ConceptualProperty(SheetRow):
               knowledge graph. Defaults to None (no transformation)
     """
 
-    class_: ClassEntityType = Field(
-        alias="Class", description="Class id that the property is defined for, strongly advise `PascalCase` usage."
+    concept: ConceptEntityType = Field(
+        alias="Concept",
+        description="Concept id that the property is defined for, strongly advise `PascalCase` usage.",
     )
     property_: ConceptualPropertyType = Field(
         alias="Property",
@@ -131,7 +133,7 @@ class ConceptualProperty(SheetRow):
     )
     name: str | None = Field(alias="Name", default=None, description="Human readable name of the property.")
     description: str | None = Field(alias="Description", default=None, description="Short description of the property.")
-    value_type: DataType | ClassEntityType | MultiValueTypeType | UnknownEntity = Field(
+    value_type: DataType | ConceptEntityType | MultiValueTypeType | UnknownEntity = Field(
         alias="Value Type",
         union_mode="left_to_right",
         description="Value type that the property can hold. It takes either subset of XSD type or a class defined.",
@@ -169,7 +171,7 @@ class ConceptualProperty(SheetRow):
     )
 
     def _identifier(self) -> tuple[Hashable, ...]:
-        return self.class_, self.property_
+        return self.concept, self.property_
 
     @field_validator("max_count", mode="before")
     def parse_max_count(cls, value: int | float | None) -> int | float | None:
@@ -201,7 +203,7 @@ class ConceptualProperty(SheetRow):
                 # this value_type.python does not seems correct. Need to check this further
                 except Exception:
                     raise PropertyDefinitionError(
-                        self.class_,
+                        self.concept,
                         "Class",
                         self.property_,
                         f"Default value {self.default} is not of type {self.value_type.python}",  # type: ignore
@@ -220,9 +222,9 @@ class ConceptualProperty(SheetRow):
             return None
         return value
 
-    @field_serializer("class_", "value_type", when_used="unless-none")
+    @field_serializer("concept", "value_type", when_used="unless-none")
     def remove_default_prefix(self, value: Any, info: SerializationInfo) -> str:
-        if (metadata := _get_metadata(info.context)) and isinstance(value, Entity):
+        if (metadata := _get_metadata(info.context)) and isinstance(value, ConceptualEntity):
             return value.dump(prefix=metadata.prefix, version=metadata.version)
         return str(value)
 
@@ -231,7 +233,7 @@ class ConceptualProperty(SheetRow):
         """Type of property based on value type. Either data (attribute) or object (edge) property."""
         if isinstance(self.value_type, DataType):
             return EntityTypes.data_property
-        elif isinstance(self.value_type, ClassEntity):
+        elif isinstance(self.value_type, ConceptEntity):
             return EntityTypes.object_property
         else:
             return EntityTypes.undefined
@@ -240,7 +242,7 @@ class ConceptualProperty(SheetRow):
 class ConceptualDataModel(BaseVerifiedDataModel):
     metadata: ConceptualMetadata = Field(alias="Metadata", description="Metadata for the conceptual data model")
     properties: SheetList[ConceptualProperty] = Field(alias="Properties", description="List of properties")
-    classes: SheetList[ConceptualClass] = Field(alias="Classes", description="List of classes")
+    concepts: SheetList[Concept] = Field(alias="Concepts", description="List of concepts")
     prefixes: dict[str, Namespace] = Field(
         alias="Prefixes",
         default_factory=get_default_prefixes_and_namespaces,
@@ -259,12 +261,12 @@ class ConceptualDataModel(BaseVerifiedDataModel):
     def set_neat_id(self) -> "ConceptualDataModel":
         namespace = self.metadata.namespace
 
-        for class_ in self.classes:
-            if not class_.neatId:
-                class_.neatId = namespace[class_.class_.suffix]
+        for concept in self.concepts:
+            if not concept.neatId:
+                concept.neatId = namespace[concept.concept.suffix]
         for property_ in self.properties:
             if not property_.neatId:
-                property_.neatId = namespace[f"{property_.class_.suffix}/{property_.property_}"]
+                property_.neatId = namespace[f"{property_.concept.suffix}/{property_.property_}"]
 
         return self
 
@@ -273,37 +275,37 @@ class ConceptualDataModel(BaseVerifiedDataModel):
 
         namespace = self.metadata.namespace
 
-        for class_ in self.classes:
-            class_.neatId = namespace[class_.class_.suffix]
+        for concept in self.concepts:
+            concept.neatId = namespace[concept.concept.suffix]
         for property_ in self.properties:
-            property_.neatId = namespace[f"{property_.class_.suffix}/{property_.property_}"]
+            property_.neatId = namespace[f"{property_.concept.suffix}/{property_.property_}"]
 
-    def sync_with_physical_data_model(self, dms_rules: "DMSRules") -> None:
+    def sync_with_physical_data_model(self, physical_data_model: "PhysicalDataModel") -> None:
         # Sync at the metadata level
-        if dms_rules.metadata.logical == self.metadata.identifier:
-            self.metadata.physical = dms_rules.metadata.identifier
+        if physical_data_model.metadata.conceptual == self.metadata.identifier:
+            self.metadata.physical = physical_data_model.metadata.identifier
         else:
             # if models are not linked to start with, we skip
             return None
 
         conceptual_properties_by_neat_id = {prop.neatId: prop for prop in self.properties}
-        physical_properties_by_neat_id = {prop.neatId: prop for prop in dms_rules.properties}
+        physical_properties_by_neat_id = {prop.neatId: prop for prop in physical_data_model.properties}
         for neat_id, prop in physical_properties_by_neat_id.items():
-            if prop.logical in conceptual_properties_by_neat_id:
-                conceptual_properties_by_neat_id[prop.logical].physical = neat_id
+            if prop.conceptual in conceptual_properties_by_neat_id:
+                conceptual_properties_by_neat_id[prop.conceptual].physical = neat_id
 
-        classes_by_neat_id = {cls.neatId: cls for cls in self.classes}
-        views_by_neat_id = {view.neatId: view for view in dms_rules.views}
+        classes_by_neat_id = {cls.neatId: cls for cls in self.concepts}
+        views_by_neat_id = {view.neatId: view for view in physical_data_model.views}
         for neat_id, view in views_by_neat_id.items():
-            if view.logical in classes_by_neat_id:
-                classes_by_neat_id[view.logical].physical = neat_id
+            if view.conceptual in classes_by_neat_id:
+                classes_by_neat_id[view.conceptual].physical = neat_id
 
-    def as_dms_rules(self) -> "DMSRules":
+    def as_dms_rules(self) -> "PhysicalDataModel":
         from cognite.neat.core._data_model.transformers._converters import (
-            _InformationRulesConverter,
+            _ConceptualDataModelConverter,
         )
 
-        return _InformationRulesConverter(self).as_dms_rules()
+        return _ConceptualDataModelConverter(self).as_physical_data_model()
 
     @classmethod
     def display_type_name(cls) -> str:
@@ -311,12 +313,12 @@ class ConceptualDataModel(BaseVerifiedDataModel):
 
     def _repr_html_(self) -> str:
         summary = {
-            "type": "Conceptual Data Model",
-            "intended for": "Information Architect",
+            "level": self.metadata.level,
+            "intended for": "Domain Expert and/or Information Architect",
             "name": self.metadata.name,
             "external_id": self.metadata.external_id,
             "version": self.metadata.version,
-            "classes": len(self.classes),
+            "concepts": len(self.concepts),
             "properties": len(self.properties),
         }
 

cognite/neat/core/_data_model/models/data_types.py

@@ -16,7 +16,7 @@ from cognite.neat.core._data_model._constants import (
     SPLIT_ON_EQUAL_PATTERN,
 )
 from cognite.neat.core._data_model.models.entities._single_value import (
-    ClassEntity,
+    ConceptEntity,
     UnitEntity,
 )
 
@@ -397,7 +397,7 @@ class Enum(DataType):
 
     name: typing.Literal["enum"] = "enum"
 
-    collection: ClassEntity
+    collection: ConceptEntity
     unknown_value: str | None = Field(None, alias="unknownValue")
 
 

cognite/neat/core/_data_model/models/entities/__init__.py

@@ -4,15 +4,15 @@ from ._multi_value import MultiValueTypeInfo
 from ._single_value import (
     AssetEntity,
     AssetFields,
-    ClassEntity,
+    ConceptEntity,
+    ConceptualEntity,
     ContainerEntity,
     DataModelEntity,
-    DMSEntity,
     DMSNodeEntity,
-    DMSUnknownEntity,
     DMSVersionedEntity,
     EdgeEntity,
-    Entity,
+    PhysicalEntity,
+    PhysicalUnknownEntity,
     ReferenceEntity,
     RelationshipEntity,
     ReverseConnectionEntity,
@@ -28,21 +28,21 @@ __all__ = [
     "AssetEntity",
     "AssetFields",
     "CdfResourceEntityList",
-    "ClassEntity",
     "ClassEntityList",
+    "ConceptEntity",
+    "ConceptualEntity",
     "ContainerEntity",
     "ContainerEntityList",
-    "DMSEntity",
     "DMSFilter",
     "DMSNodeEntity",
-    "DMSUnknownEntity",
     "DMSVersionedEntity",
     "DataModelEntity",
     "EdgeEntity",
-    "Entity",
     "HasDataFilter",
     "MultiValueTypeInfo",
     "NodeTypeFilter",
+    "PhysicalEntity",
+    "PhysicalUnknownEntity",
     "RawFilter",
     "ReferenceEntity",
     "RelationshipEntity",

cognite/neat/core/_data_model/models/entities/_loaders.py

@@ -5,9 +5,9 @@ from cognite.neat.core._issues.errors import NeatTypeError
 
 from ._multi_value import MultiValueTypeInfo
 from ._single_value import (
-    ClassEntity,
-    DMSUnknownEntity,
+    ConceptEntity,
     EdgeEntity,
+    PhysicalUnknownEntity,
     ReverseConnectionEntity,
     Unknown,
     UnknownEntity,
@@ -16,9 +16,10 @@ from ._single_value import (
 
 
 def load_value_type(
-    raw: str | MultiValueTypeInfo | DataType | ClassEntity | UnknownEntity, default_prefix: str
-) -> MultiValueTypeInfo | DataType | ClassEntity | UnknownEntity:
-    if isinstance(raw, MultiValueTypeInfo | DataType | ClassEntity | UnknownEntity):
+    raw: str | MultiValueTypeInfo | DataType | ConceptEntity | UnknownEntity,
+    default_prefix: str,
+) -> MultiValueTypeInfo | DataType | ConceptEntity | UnknownEntity:
+    if isinstance(raw, MultiValueTypeInfo | DataType | ConceptEntity | UnknownEntity):
         return raw
     elif isinstance(raw, str):
         # property holding xsd data type
@@ -36,23 +37,23 @@ def load_value_type(
 
         # property holding link to class
         else:
-            return ClassEntity.load(raw, prefix=default_prefix)
+            return ConceptEntity.load(raw, prefix=default_prefix)
     else:
         raise NeatTypeError(f"Invalid value type: {type(raw)}")
 
 
 def load_dms_value_type(
-    raw: str | DataType | ViewEntity | DMSUnknownEntity,
+    raw: str | DataType | ViewEntity | PhysicalUnknownEntity,
     default_space: str,
     default_version: str,
-) -> DataType | ViewEntity | DMSUnknownEntity:
-    if isinstance(raw, DataType | ViewEntity | DMSUnknownEntity):
+) -> DataType | ViewEntity | PhysicalUnknownEntity:
+    if isinstance(raw, DataType | ViewEntity | PhysicalUnknownEntity):
         return raw
     elif isinstance(raw, str):
         if DataType.is_data_type(raw):
             return DataType.load(raw)
         elif raw == str(Unknown):
-            return DMSUnknownEntity()
+            return PhysicalUnknownEntity()
         else:
             return ViewEntity.load(raw, space=default_space, version=default_version)
     raise NeatTypeError(f"Invalid value type: {type(raw)}")

cognite/neat/core/_data_model/models/entities/_multi_value.py

@@ -10,12 +10,12 @@ from cognite.neat.core._data_model._constants import EntityTypes
 from cognite.neat.core._data_model.models.data_types import DataType
 
 from ._constants import _PARSE, Undefined
-from ._single_value import ClassEntity, UnknownEntity
+from ._single_value import ConceptEntity, UnknownEntity
 
 
 class MultiValueTypeInfo(BaseModel):
     type_: ClassVar[EntityTypes] = EntityTypes.multi_value_type
-    types: list[DataType | ClassEntity]
+    types: list[DataType | ConceptEntity]
 
     def __str__(self) -> str:
         return ", ".join([str(t) for t in self.types])
@@ -57,19 +57,19 @@ class MultiValueTypeInfo(BaseModel):
         else:
             return {
                 "types": [
-                    (DataType.load(type_) if DataType.is_data_type(type_) else ClassEntity.load(type_))
+                    (DataType.load(type_) if DataType.is_data_type(type_) else ConceptEntity.load(type_))
                     for type_ in types
                 ]
             }
 
     def set_default_prefix(self, prefix: str) -> None:
         for type_ in self.types:
-            if isinstance(type_, ClassEntity) and type_.prefix is Undefined:
+            if isinstance(type_, ConceptEntity) and type_.prefix is Undefined:
                 type_.prefix = prefix
 
     def is_multi_object_type(self) -> bool:
         """Will signalize to DMS converter to create connection to unknown Node type"""
-        return all(isinstance(t, ClassEntity) for t in self.types)
+        return all(isinstance(t, ConceptEntity) for t in self.types)
 
     def is_multi_data_type(self) -> bool:
         """Will signalize to DMS converter to attempt to find the best data type for value"""

cognite/neat/core/_data_model/models/entities/_single_value.py

@@ -50,8 +50,8 @@ from ._constants import (
 
 
 @total_ordering
-class Entity(BaseModel, extra="ignore"):
-    """Entity is a class or property in OWL/RDF sense."""
+class ConceptualEntity(BaseModel, extra="ignore"):
+    """Conceptual Entity is a concept, class or property in semantics sense."""
 
     type_: ClassVar[EntityTypes] = EntityTypes.undefined
     prefix: str | _UndefinedType = Undefined
@@ -64,7 +64,10 @@ class Entity(BaseModel, extra="ignore"):
     @classmethod
     @overload
     def load(
-        cls: "type[T_Entity]", data: Any, strict: Literal[False] = False, **defaults: Any
+        cls: "type[T_Entity]",
+        data: Any,
+        strict: Literal[False] = False,
+        **defaults: Any,
     ) -> "T_Entity | UnknownEntity": ...
 
     @classmethod
@@ -85,7 +88,7 @@ class Entity(BaseModel, extra="ignore"):
             return cls.model_validate(data)
 
     @model_validator(mode="before")
-    def _load(cls, data: Any) -> "dict | Entity":
+    def _load(cls, data: Any) -> "dict | ConceptualEntity":
         defaults = {}
         if isinstance(data, dict) and _PARSE in data:
             defaults = data.get("defaults", {})
@@ -157,7 +160,7 @@ class Entity(BaseModel, extra="ignore"):
             if isinstance(annotation, UnionType) or get_origin(annotation) is Union:
                 annotation = get_args(annotation)[0]
 
-            if inspect.isclass(annotation) and issubclass(annotation, Entity):  # type: ignore[arg-type]
+            if inspect.isclass(annotation) and issubclass(annotation, ConceptualEntity):  # type: ignore[arg-type]
                 extra_args[key] = annotation.load(extra_args[key], **defaults)  # type: ignore[union-attr, assignment]
         return dict(prefix=prefix, suffix=suffix, **extra_args)
 
@@ -179,12 +182,12 @@ class Entity(BaseModel, extra="ignore"):
             return self.prefix, str(self.suffix), *extra
 
     def __lt__(self, other: object) -> bool:
-        if not isinstance(other, Entity):
+        if not isinstance(other, ConceptualEntity):
             return NotImplemented
         return self.as_tuple() < other.as_tuple()
 
     def __eq__(self, other: object) -> bool:
-        if not isinstance(other, Entity):
+        if not isinstance(other, ConceptualEntity):
             return NotImplemented
         return self.as_tuple() == other.as_tuple()
 
@@ -207,7 +210,7 @@ class Entity(BaseModel, extra="ignore"):
     def _as_str(self, **defaults: Any) -> str:
         # We have overwritten the serialization to str, so we need to do it manually
         model_dump = {
-            field.alias or field_name: v.dump(**defaults) if isinstance(v, Entity) else v
+            field.alias or field_name: v.dump(**defaults) if isinstance(v, ConceptualEntity) else v
             for field_name, field in self.model_fields.items()
             if (v := getattr(self, field_name)) is not None and field_name not in {"prefix", "suffix"}
         }
@@ -263,11 +266,11 @@ class Entity(BaseModel, extra="ignore"):
         return new_entity
 
 
-T_Entity = TypeVar("T_Entity", bound=Entity)
+T_Entity = TypeVar("T_Entity", bound=ConceptualEntity)
 
 
-class ClassEntity(Entity):
-    type_: ClassVar[EntityTypes] = EntityTypes.class_
+class ConceptEntity(ConceptualEntity):
+    type_: ClassVar[EntityTypes] = EntityTypes.concept
     version: str | None = None
 
     def as_view_entity(self, default_space: str, default_version: str) -> "ViewEntity":
@@ -283,7 +286,7 @@ class ClassEntity(Entity):
         return ContainerEntity(space=space, externalId=str(self.suffix))
 
 
-class UnknownEntity(ClassEntity):
+class UnknownEntity(ConceptEntity):
     type_: ClassVar[EntityTypes] = EntityTypes.undefined
     prefix: _UndefinedType = Undefined
     suffix: _UnknownType = Unknown  # type: ignore[assignment]
@@ -293,7 +296,7 @@ class UnknownEntity(ClassEntity):
         return str(Unknown)
 
 
-class UnitEntity(Entity):
+class UnitEntity(ConceptualEntity):
     type_: ClassVar[EntityTypes] = EntityTypes.unit
     prefix: str
     suffix: str
@@ -310,14 +313,14 @@ class AssetFields(StrEnum):
     metadata = "metadata"
 
 
-class AssetEntity(Entity):
+class AssetEntity(ConceptualEntity):
     type_: ClassVar[EntityTypes] = EntityTypes.asset
     suffix: str = "Asset"
     prefix: _UndefinedType = Undefined
     property_: AssetFields = Field(alias="property")
 
 
-class RelationshipEntity(Entity):
+class RelationshipEntity(ConceptualEntity):
     type_: ClassVar[EntityTypes] = EntityTypes.relationship
     suffix: str = "Relationship"
     prefix: _UndefinedType = Undefined
@@ -327,7 +330,7 @@ class RelationshipEntity(Entity):
 T_ID = TypeVar("T_ID", bound=ContainerId | ViewId | DataModelId | PropertyId | NodeId | None)
 
 
-class DMSEntity(Entity, Generic[T_ID], ABC):
+class PhysicalEntity(ConceptualEntity, Generic[T_ID], ABC):
     type_: ClassVar[EntityTypes] = EntityTypes.undefined
     prefix: str = Field(alias="space")
     suffix: str = Field(alias="externalId")
@@ -344,17 +347,20 @@ class DMSEntity(Entity, Generic[T_ID], ABC):
     @classmethod
     @overload
     def load(
-        cls: "type[T_DMSEntity]", data: Any, strict: Literal[False] = False, **defaults: Any
-    ) -> "T_DMSEntity | DMSUnknownEntity": ...
+        cls: "type[T_DMSEntity]",
+        data: Any,
+        strict: Literal[False] = False,
+        **defaults: Any,
+    ) -> "T_DMSEntity | PhysicalUnknownEntity": ...
 
     @classmethod
     def load(
         cls: "type[T_DMSEntity]", data: Any, strict: bool = False, **defaults: Any
-    ) -> "T_DMSEntity | DMSUnknownEntity":  # type: ignore
+    ) -> "T_DMSEntity | PhysicalUnknownEntity":  # type: ignore
         if isinstance(data, str) and data == str(Unknown):
             if strict:
                 raise NeatValueError(f"Failed to load entity {data!s}")
-            return DMSUnknownEntity.from_id(None)
+            return PhysicalUnknownEntity.from_id(None)
         return cast(T_DMSEntity, super().load(data, **defaults))
 
     @property
@@ -376,8 +382,8 @@ class DMSEntity(Entity, Generic[T_ID], ABC):
     def from_id(cls, id: T_ID) -> Self:
         raise NotImplementedError("Method from_id must be implemented in subclasses")
 
-    def as_class(self) -> ClassEntity:
-        return ClassEntity(prefix=self.space, suffix=self.external_id)
+    def as_concept_entity(self) -> ConceptEntity:
+        return ConceptEntity(prefix=self.space, suffix=self.external_id)
 
     def as_dms_compliant_entity(self) -> "Self":
         new_entity = self.model_copy(deep=True)
@@ -385,10 +391,10 @@ class DMSEntity(Entity, Generic[T_ID], ABC):
         return new_entity
 
 
-T_DMSEntity = TypeVar("T_DMSEntity", bound=DMSEntity)
+T_DMSEntity = TypeVar("T_DMSEntity", bound=PhysicalEntity)
 
 
-class ContainerEntity(DMSEntity[ContainerId]):
+class ContainerEntity(PhysicalEntity[ContainerId]):
     type_: ClassVar[EntityTypes] = EntityTypes.container
 
     def as_id(self) -> ContainerId:
@@ -399,13 +405,13 @@ class ContainerEntity(DMSEntity[ContainerId]):
         return cls(space=id.space, externalId=id.external_id)
 
 
-class DMSVersionedEntity(DMSEntity[T_ID], ABC):
+class DMSVersionedEntity(PhysicalEntity[T_ID], ABC):
     version: str
 
-    def as_class(self, skip_version: bool = False) -> ClassEntity:
+    def as_concept_entity(self, skip_version: bool = False) -> ConceptEntity:
         if skip_version:
-            return ClassEntity(prefix=self.space, suffix=self.external_id)
-        return ClassEntity(prefix=self.space, suffix=self.external_id, version=self.version)
+            return ConceptEntity(prefix=self.space, suffix=self.external_id)
+        return ConceptEntity(prefix=self.space, suffix=self.external_id, version=self.version)
 
 
 class ViewEntity(DMSVersionedEntity[ViewId]):
@@ -429,7 +435,7 @@ class ViewEntity(DMSVersionedEntity[ViewId]):
             raise ValueError("Version must be specified")
 
 
-class DMSUnknownEntity(DMSEntity[None]):
+class PhysicalUnknownEntity(PhysicalEntity[None]):
     """This is a special entity that represents an unknown entity.
 
     The use case is for direct relations where the source is not known."""
@@ -442,7 +448,7 @@ class DMSUnknownEntity(DMSEntity[None]):
         return None
 
     @classmethod
-    def from_id(cls, id: None) -> "DMSUnknownEntity":
+    def from_id(cls, id: None) -> "PhysicalUnknownEntity":
         return cls(space=Undefined, externalId=Unknown)
 
     @property
@@ -463,7 +469,7 @@ class DataModelEntity(DMSVersionedEntity[DataModelId]):
         return cls(space=id.space, externalId=id.external_id, version=id.version)
 
 
-class DMSNodeEntity(DMSEntity[NodeId]):
+class DMSNodeEntity(PhysicalEntity[NodeId]):
     type_: ClassVar[EntityTypes] = EntityTypes.dms_node
 
     def as_id(self) -> NodeId:
@@ -481,7 +487,7 @@ class DMSNodeEntity(DMSEntity[NodeId]):
         return cls(space=ref.space, externalId=ref.external_id)
 
 
-class EdgeEntity(DMSEntity[None]):
+class EdgeEntity(PhysicalEntity[None]):
     type_: ClassVar[EntityTypes] = EntityTypes.edge
     prefix: _UndefinedType = Undefined  # type: ignore[assignment]
     suffix: Literal["edge"] = "edge"
@@ -501,21 +507,21 @@ class EdgeEntity(DMSEntity[None]):
         return cls()
 
 
-class ReverseConnectionEntity(Entity):
+class ReverseConnectionEntity(ConceptualEntity):
     type_: ClassVar[EntityTypes] = EntityTypes.reverse
     prefix: _UndefinedType = Undefined
     suffix: Literal["reverse"] = "reverse"
     property_: str = Field(alias="property")
 
 
-class ReferenceEntity(ClassEntity):
+class ReferenceEntity(ConceptEntity):
     type_: ClassVar[EntityTypes] = EntityTypes.reference_entity
     prefix: str
     property_: str | None = Field(None, alias="property")
 
     @classmethod
-    def from_entity(cls, entity: Entity, property_: str) -> "ReferenceEntity":
-        if isinstance(entity, ClassEntity):
+    def from_entity(cls, entity: ConceptualEntity, property_: str) -> "ReferenceEntity":
+        if isinstance(entity, ConceptEntity):
             return cls(
                 prefix=str(entity.prefix),
                 suffix=entity.suffix,
@@ -541,5 +547,5 @@ class ReferenceEntity(ClassEntity):
     def as_node_entity(self) -> DMSNodeEntity:
         return DMSNodeEntity(space=self.prefix, externalId=self.suffix)
 
-    def as_class_entity(self) -> ClassEntity:
-        return ClassEntity(prefix=self.prefix, suffix=self.suffix, version=self.version)
+    def as_concept_entity(self) -> ConceptEntity:
+        return ConceptEntity(prefix=self.prefix, suffix=self.suffix, version=self.version)