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

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

@@ -6,7 +6,13 @@ from pydantic import (
     PlainSerializer,
 )
 
-from ._single_value import AssetEntity, ClassEntity, ContainerEntity, RelationshipEntity, ViewEntity
+from ._single_value import (
+    AssetEntity,
+    ConceptEntity,
+    ContainerEntity,
+    RelationshipEntity,
+    ViewEntity,
+)
 
 
 def _split_str(v: Any) -> list[str]:
@@ -15,7 +21,7 @@ def _split_str(v: Any) -> list[str]:
     return v
 
 
-def _join_str(v: list[ClassEntity]) -> str | None:
+def _join_str(v: list[ConceptEntity]) -> str | None:
     return ",".join([entry.id for entry in v]) if v else None
 
 
@@ -39,7 +45,7 @@ def _generate_cdf_resource_list(v: Any) -> list[AssetEntity | RelationshipEntity
 
 
 ClassEntityList = Annotated[
-    list[ClassEntity],
+    list[ConceptEntity],
     BeforeValidator(_split_str),
 ]
 

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

@@ -8,14 +8,14 @@ from cognite.client import data_modeling as dm
 from cognite.client.data_classes.data_modeling import ContainerId, NodeId
 from pydantic import BaseModel, model_serializer, model_validator
 
-from ._single_value import ContainerEntity, DMSNodeEntity, Entity, ViewEntity
+from ._single_value import ConceptualEntity, ContainerEntity, DMSNodeEntity, ViewEntity
 
 
 @total_ordering
 class WrappedEntity(BaseModel, ABC):
     name: ClassVar[str]
-    _inner_cls: ClassVar[type[Entity]]
-    inner: list[Entity] | None
+    _inner_cls: ClassVar[type[ConceptualEntity]]
+    inner: list[ConceptualEntity] | None
 
     @classmethod
     def load(cls: "type[T_WrappedEntity]", data: Any) -> "T_WrappedEntity":

cognite/neat/core/_data_model/models/mapping/_classic2core.py

@@ -3,8 +3,11 @@ from pathlib import Path
 
 import yaml
 
-from cognite.neat.core._data_model._shared import ReadRules
-from cognite.neat.core._data_model.models.dms import DMSInputRules, DMSRules
+from cognite.neat.core._data_model._shared import ImportedDataModel
+from cognite.neat.core._data_model.models.physical import (
+    PhysicalDataModel,
+    UnverifiedPhysicalDataModel,
+)
 from cognite.neat.core._issues.errors import NeatValueError
 
 _CLASSIC_TO_CORE_MAPPING = Path(__file__).resolve().parent / "_classic2core.yaml"
@@ -15,9 +18,9 @@ def _read_source_file() -> str:
     return _CLASSIC_TO_CORE_MAPPING.read_text()
 
 
-def load_classic_to_core_mapping(org_name: str | None, source_space: str, source_version: str) -> DMSRules:
-    from cognite.neat.core._data_model.importers import YAMLImporter
-    from cognite.neat.core._data_model.transformers import VerifyDMSRules
+def load_classic_to_core_mapping(org_name: str | None, source_space: str, source_version: str) -> PhysicalDataModel:
+    from cognite.neat.core._data_model.importers import DictImporter
+    from cognite.neat.core._data_model.transformers import VerifyPhysicalDataModel
 
     raw_str = _read_source_file()
     if org_name is not None:
@@ -27,10 +30,10 @@ def load_classic_to_core_mapping(org_name: str | None, source_space: str, source
     loaded["metadata"]["space"] = source_space
     loaded["metadata"]["version"] = source_version
 
-    read: ReadRules[DMSInputRules] = YAMLImporter(loaded).to_rules()
-    if not isinstance(read.rules, DMSInputRules):
-        raise NeatValueError(f"Expected DMS rules, but got {type(read.rules).__name__}")
+    read: ImportedDataModel[UnverifiedPhysicalDataModel] = DictImporter(loaded).to_data_model()
+    if not isinstance(read.unverified_data_model, UnverifiedPhysicalDataModel):
+        raise NeatValueError(f"Expected DMS rules, but got {type(read.unverified_data_model).__name__}")
 
-    verified = VerifyDMSRules(validate=False).transform(read)
+    verified = VerifyPhysicalDataModel(validate=False).transform(read)
 
     return verified

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

@@ -0,0 +1,40 @@
+from cognite.neat.core._client.data_classes.schema import DMSSchema
+
+from ._unverified import (
+    UnverifiedPhysicalContainer,
+    UnverifiedPhysicalDataModel,
+    UnverifiedPhysicalEnum,
+    UnverifiedPhysicalMetadata,
+    UnverifiedPhysicalNodeType,
+    UnverifiedPhysicalProperty,
+    UnverifiedPhysicalView,
+)
+from ._validation import PhysicalValidation
+from ._verified import (
+    PhysicalContainer,
+    PhysicalDataModel,
+    PhysicalEnum,
+    PhysicalMetadata,
+    PhysicalNodeType,
+    PhysicalProperty,
+    PhysicalView,
+)
+
+__all__ = [
+    "DMSSchema",
+    "PhysicalContainer",
+    "PhysicalDataModel",
+    "PhysicalEnum",
+    "PhysicalMetadata",
+    "PhysicalNodeType",
+    "PhysicalProperty",
+    "PhysicalValidation",
+    "PhysicalView",
+    "UnverifiedPhysicalContainer",
+    "UnverifiedPhysicalDataModel",
+    "UnverifiedPhysicalEnum",
+    "UnverifiedPhysicalMetadata",
+    "UnverifiedPhysicalNodeType",
+    "UnverifiedPhysicalProperty",
+    "UnverifiedPhysicalView",
+]

cognite/neat/core/_data_model/models/{dms → physical}/_exporter.py

@@ -27,14 +27,14 @@ from cognite.neat.core._constants import (
 )
 from cognite.neat.core._data_model.models.data_types import DataType, Double, Enum, Float
 from cognite.neat.core._data_model.models.entities import (
-    ClassEntity,
+    ConceptEntity,
     ContainerEntity,
     DMSFilter,
     DMSNodeEntity,
-    DMSUnknownEntity,
     EdgeEntity,
     HasDataFilter,
     NodeTypeFilter,
+    PhysicalUnknownEntity,
     ReverseConnectionEntity,
     UnitEntity,
     ViewEntity,
@@ -53,7 +53,13 @@ from cognite.neat.core._issues.warnings.user_modeling import (
     HasDataFilterOnNoPropertiesViewWarning,
 )
 
-from ._rules import DMSEnum, DMSMetadata, DMSProperty, DMSRules, DMSView
+from ._verified import (
+    PhysicalDataModel,
+    PhysicalEnum,
+    PhysicalMetadata,
+    PhysicalProperty,
+    PhysicalView,
+)
 
 
 class _DMSExporter:
@@ -69,29 +75,34 @@ class _DMSExporter:
         remove_cdf_spaces(bool): The
     """
 
-    def __init__(self, rules: DMSRules, instance_space: str | None = None, remove_cdf_spaces: bool = False):
+    def __init__(
+        self,
+        data_model: PhysicalDataModel,
+        instance_space: str | None = None,
+        remove_cdf_spaces: bool = False,
+    ):
         self.instance_space = instance_space
-        self.rules = rules
+        self.data_model = data_model
         self.remove_cdf_spaces = remove_cdf_spaces
 
     def to_schema(self) -> DMSSchema:
-        rules = self.rules
-        container_properties_by_id, view_properties_by_id = self._gather_properties(list(self.rules.properties))
+        data_model = self.data_model
+        container_properties_by_id, view_properties_by_id = self._gather_properties(list(self.data_model.properties))
 
-        containers = self._create_containers(container_properties_by_id, rules.enum)  # type: ignore[arg-type]
+        containers = self._create_containers(container_properties_by_id, data_model.enum)  # type: ignore[arg-type]
 
         view_properties_with_ancestors_by_id = self._gather_properties_with_ancestors(
-            view_properties_by_id, rules.views
+            view_properties_by_id, data_model.views
         )
 
         views = self._create_views(view_properties_by_id, view_properties_with_ancestors_by_id)
         view_node_type_filters: set[dm.NodeId] = set()
-        for dms_view in rules.views:
+        for dms_view in data_model.views:
             if isinstance(dms_view.filter_, NodeTypeFilter):
                 view_node_type_filters.update(node.as_id() for node in dms_view.filter_.inner or [])
-        if rules.nodes:
+        if data_model.nodes:
             node_types = NodeApplyDict(
-                [node.as_node() for node in rules.nodes]
+                [node.as_node() for node in data_model.nodes]
                 + [dm.NodeApply(node.space, node.external_id) for node in view_node_type_filters]
             )
         else:
@@ -103,17 +114,17 @@ class _DMSExporter:
                 ]
             )
 
-        data_model = rules.metadata.as_data_model()
+        dms_data_model = data_model.metadata.as_data_model()
         # Sorting to ensure deterministic order
-        data_model.views = sorted(
-            [dms_view.view.as_id() for dms_view in rules.views if dms_view.in_model],
+        dms_data_model.views = sorted(
+            [dms_view.view.as_id() for dms_view in data_model.views if dms_view.in_model],
             key=lambda x: x.as_tuple(),  # type: ignore[union-attr]
         )
-        spaces = self._create_spaces(rules.metadata, containers, views, data_model)
+        spaces = self._create_spaces(data_model.metadata, containers, views, dms_data_model)
 
         return DMSSchema(
             spaces=spaces,
-            data_model=data_model,
+            data_model=dms_data_model,
             views=views,
             containers=containers,
             node_types=node_types,
@@ -121,7 +132,7 @@ class _DMSExporter:
 
     def _create_spaces(
         self,
-        metadata: DMSMetadata,
+        metadata: PhysicalMetadata,
         containers: ContainerApplyDict,
         views: ViewApplyDict,
         data_model: dm.DataModelApply,
@@ -140,10 +151,10 @@ class _DMSExporter:
 
     def _create_views(
         self,
-        view_properties_by_id: dict[dm.ViewId, list[DMSProperty]],
-        view_properties_with_ancestors_by_id: dict[dm.ViewId, list[DMSProperty]],
+        view_properties_by_id: dict[dm.ViewId, list[PhysicalProperty]],
+        view_properties_with_ancestors_by_id: dict[dm.ViewId, list[PhysicalProperty]],
     ) -> ViewApplyDict:
-        input_views = list(self.rules.views)
+        input_views = list(self.data_model.views)
 
         views = ViewApplyDict(
             [
@@ -172,7 +183,7 @@ class _DMSExporter:
         return views
 
     @classmethod
-    def _create_edge_type_from_prop(cls, prop: DMSProperty) -> dm.DirectRelationReference:
+    def _create_edge_type_from_prop(cls, prop: PhysicalProperty) -> dm.DirectRelationReference:
         if isinstance(prop.connection, EdgeEntity) and prop.connection.edge_type is not None:
             return prop.connection.edge_type.as_reference()
         elif isinstance(prop.value_type, ViewEntity):
@@ -191,10 +202,10 @@ class _DMSExporter:
     @classmethod
     def _edge_types_by_view_property_id(
         cls,
-        view_properties_with_ancestors_by_id: dict[dm.ViewId, list[DMSProperty]],
-        view_by_id: dict[ViewEntity, DMSView],
+        view_properties_with_ancestors_by_id: dict[dm.ViewId, list[PhysicalProperty]],
+        view_by_id: dict[ViewEntity, PhysicalView],
     ) -> dict[tuple[ViewEntity, str], dm.DirectRelationReference]:
-        edge_connection_property_by_view_property_id: dict[tuple[ViewEntity, str], DMSProperty] = {}
+        edge_connection_property_by_view_property_id: dict[tuple[ViewEntity, str], PhysicalProperty] = {}
         for properties in view_properties_with_ancestors_by_id.values():
             for prop in properties:
                 if isinstance(prop.connection, EdgeEntity):
@@ -248,10 +259,10 @@ class _DMSExporter:
     @classmethod
     def _get_edge_type_outwards_connection(
         cls,
-        view: DMSView,
-        prop: DMSProperty,
-        view_by_id: dict[ViewEntity, DMSView],
-        edge_connection_by_view_property_id: dict[tuple[ViewEntity, str], DMSProperty],
+        view: PhysicalView,
+        prop: PhysicalProperty,
+        view_by_id: dict[ViewEntity, PhysicalView],
+        edge_connection_by_view_property_id: dict[tuple[ViewEntity, str], PhysicalProperty],
     ) -> dm.DirectRelationReference:
         connection = cast(EdgeEntity, prop.connection)
         if connection.edge_type is not None:
@@ -284,14 +295,14 @@ class _DMSExporter:
 
     def _create_containers(
         self,
-        container_properties_by_id: dict[dm.ContainerId, list[DMSProperty]],
-        enum: Collection[DMSEnum] | None,
+        container_properties_by_id: dict[dm.ContainerId, list[PhysicalProperty]],
+        enum: Collection[PhysicalEnum] | None,
     ) -> ContainerApplyDict:
-        enum_values_by_collection: dict[ClassEntity, list[DMSEnum]] = defaultdict(list)
+        enum_values_by_collection: dict[ConceptEntity, list[PhysicalEnum]] = defaultdict(list)
         for enum_value in enum or []:
             enum_values_by_collection[enum_value.collection].append(enum_value)
 
-        containers = list(self.rules.containers or [])
+        containers = list(self.data_model.containers or [])
 
         containers = dm.ContainerApplyList(
             [
@@ -390,10 +401,13 @@ class _DMSExporter:
 
     @staticmethod
     def _gather_properties(
-        properties: Sequence[DMSProperty],
-    ) -> tuple[dict[dm.ContainerId, list[DMSProperty]], dict[dm.ViewId, list[DMSProperty]]]:
-        container_properties_by_id: dict[dm.ContainerId, list[DMSProperty]] = defaultdict(list)
-        view_properties_by_id: dict[dm.ViewId, list[DMSProperty]] = defaultdict(list)
+        properties: Sequence[PhysicalProperty],
+    ) -> tuple[
+        dict[dm.ContainerId, list[PhysicalProperty]],
+        dict[dm.ViewId, list[PhysicalProperty]],
+    ]:
+        container_properties_by_id: dict[dm.ContainerId, list[PhysicalProperty]] = defaultdict(list)
+        view_properties_by_id: dict[dm.ViewId, list[PhysicalProperty]] = defaultdict(list)
         for prop in properties:
             view_id = prop.view.as_id()
             view_properties_by_id[view_id].append(prop)
@@ -406,12 +420,12 @@ class _DMSExporter:
 
     def _gather_properties_with_ancestors(
         self,
-        view_properties_by_id: dict[dm.ViewId, list[DMSProperty]],
-        views: Sequence[DMSView],
-    ) -> dict[dm.ViewId, list[DMSProperty]]:
+        view_properties_by_id: dict[dm.ViewId, list[PhysicalProperty]],
+        views: Sequence[PhysicalView],
+    ) -> dict[dm.ViewId, list[PhysicalProperty]]:
         all_view_properties_by_id = view_properties_by_id.copy()
 
-        view_properties_with_parents_by_id: dict[dm.ViewId, list[DMSProperty]] = defaultdict(list)
+        view_properties_with_parents_by_id: dict[dm.ViewId, list[PhysicalProperty]] = defaultdict(list)
         view_by_view_id = {view.view.as_id(): view for view in views}
         for view in views:
             view_id = view.view.as_id()
@@ -446,9 +460,9 @@ class _DMSExporter:
     @classmethod
     def _update_with_properties(
         cls,
-        selected_properties: Sequence[DMSProperty],
-        container_properties_by_id: dict[dm.ContainerId, list[DMSProperty]],
-        view_properties_by_id: dict[dm.ViewId, list[DMSProperty]] | None,
+        selected_properties: Sequence[PhysicalProperty],
+        container_properties_by_id: dict[dm.ContainerId, list[PhysicalProperty]],
+        view_properties_by_id: dict[dm.ViewId, list[PhysicalProperty]] | None,
         include_new_containers: bool = False,
     ) -> None:
         view_properties_by_id = view_properties_by_id or {}
@@ -472,7 +486,7 @@ class _DMSExporter:
     def _create_view_filter(
         self,
         view: dm.ViewApply,
-        dms_view: DMSView | None,
+        dms_view: PhysicalView | None,
     ) -> DMSFilter | None:
         selected_filter_name = (dms_view and dms_view.filter_ and dms_view.filter_.name) or ""
 
@@ -497,8 +511,8 @@ class _DMSExporter:
     @classmethod
     def _create_view_property(
         cls,
-        prop: DMSProperty,
-        view_properties_with_ancestors_by_id: dict[dm.ViewId, list[DMSProperty]],
+        prop: PhysicalProperty,
+        view_properties_with_ancestors_by_id: dict[dm.ViewId, list[PhysicalProperty]],
         edge_types_by_view_property_id: dict[tuple[ViewEntity, str], dm.DirectRelationReference],
     ) -> ViewPropertyApply | None:
         if prop.container and prop.container_property:
@@ -509,19 +523,20 @@ class _DMSExporter:
             return cls._create_reverse_direct_relation(prop, view_properties_with_ancestors_by_id)
         elif prop.view and prop.view_property and prop.connection:
             warnings.warn(
-                NotSupportedWarning(f"{prop.connection} in {prop.view.as_id()!r}.{prop.view_property}"), stacklevel=2
+                NotSupportedWarning(f"{prop.connection} in {prop.view.as_id()!r}.{prop.view_property}"),
+                stacklevel=2,
             )
         return None
 
     @classmethod
-    def _create_mapped_property(cls, prop: DMSProperty) -> dm.MappedPropertyApply:
+    def _create_mapped_property(cls, prop: PhysicalProperty) -> dm.MappedPropertyApply:
         container = cast(ContainerEntity, prop.container)
         container_prop_identifier = cast(str, prop.container_property)
         extra_args: dict[str, Any] = {}
         if prop.connection == "direct":
             if isinstance(prop.value_type, ViewEntity):
                 extra_args["source"] = prop.value_type.as_id()
-            elif isinstance(prop.value_type, DMSUnknownEntity):
+            elif isinstance(prop.value_type, PhysicalUnknownEntity):
                 extra_args["source"] = None
             else:
                 # Should have been validated.
@@ -545,7 +560,9 @@ class _DMSExporter:
 
     @classmethod
     def _create_edge_property(
-        cls, prop: DMSProperty, edge_types_by_view_property_id: dict[tuple[ViewEntity, str], dm.DirectRelationReference]
+        cls,
+        prop: PhysicalProperty,
+        edge_types_by_view_property_id: dict[tuple[ViewEntity, str], dm.DirectRelationReference],
     ) -> dm.EdgeConnectionApply:
         connection = cast(EdgeEntity, prop.connection)
         if isinstance(prop.value_type, ViewEntity):
@@ -575,7 +592,9 @@ class _DMSExporter:
 
     @classmethod
     def _create_reverse_direct_relation(
-        cls, prop: DMSProperty, view_properties_with_ancestors_by_id: dict[dm.ViewId, list[DMSProperty]]
+        cls,
+        prop: PhysicalProperty,
+        view_properties_with_ancestors_by_id: dict[dm.ViewId, list[PhysicalProperty]],
     ) -> dm.MultiReverseDirectRelationApply | SingleReverseDirectRelationApply | None:
         connection = cast(ReverseConnectionEntity, prop.connection)
         reverse_prop_id = connection.property_

cognite/neat/core/_data_model/models/{dms/_rules_input.py → physical/_unverified.py}

@@ -22,8 +22,8 @@ from cognite.neat.core._data_model.models.data_types import DataType
 from cognite.neat.core._data_model.models.entities import (
     ContainerEntity,
     DMSNodeEntity,
-    DMSUnknownEntity,
     EdgeEntity,
+    PhysicalUnknownEntity,
     ReverseConnectionEntity,
     ViewEntity,
     load_connection,
@@ -33,7 +33,16 @@ from cognite.neat.core._data_model.models.entities._wrapped import DMSFilter
 from cognite.neat.core._issues.warnings import DeprecatedWarning
 from cognite.neat.core._utils.rdf_ import uri_display_name
 
-from ._rules import _DEFAULT_VERSION, DMSContainer, DMSEnum, DMSMetadata, DMSNode, DMSProperty, DMSRules, DMSView
+from ._verified import (
+    _DEFAULT_VERSION,
+    PhysicalContainer,
+    PhysicalDataModel,
+    PhysicalEnum,
+    PhysicalMetadata,
+    PhysicalNodeType,
+    PhysicalProperty,
+    PhysicalView,
+)
 
 if sys.version_info >= (3, 11):
     from typing import Self
@@ -42,7 +51,7 @@ else:
 
 
 @dataclass
-class DMSInputMetadata(UnverifiedComponent[DMSMetadata]):
+class UnverifiedPhysicalMetadata(UnverifiedComponent[PhysicalMetadata]):
     space: str
     external_id: str
     creator: str
@@ -51,12 +60,12 @@ class DMSInputMetadata(UnverifiedComponent[DMSMetadata]):
     description: str | None = None
     created: datetime | str | None = None
     updated: datetime | str | None = None
-    logical: str | URIRef | None = None
+    conceptual: str | URIRef | None = None
     source_id: str | URIRef | None = None
 
     @classmethod
-    def _get_verified_cls(cls) -> type[DMSMetadata]:
-        return DMSMetadata
+    def _get_verified_cls(cls) -> type[PhysicalMetadata]:
+        return PhysicalMetadata
 
     def dump(self) -> dict[str, Any]:  # type: ignore[override]
         output = super().dump()
@@ -67,7 +76,7 @@ class DMSInputMetadata(UnverifiedComponent[DMSMetadata]):
         return output
 
     @classmethod
-    def from_data_model(cls, data_model: dm.DataModelApply) -> "DMSInputMetadata":
+    def from_data_model(cls, data_model: dm.DataModelApply) -> "UnverifiedPhysicalMetadata":
         description, creator = cls._get_description_and_creator(data_model.description)
         return cls(
             space=data_model.space,
@@ -113,10 +122,10 @@ class DMSInputMetadata(UnverifiedComponent[DMSMetadata]):
 
 
 @dataclass
-class DMSInputProperty(UnverifiedComponent[DMSProperty]):
+class UnverifiedPhysicalProperty(UnverifiedComponent[PhysicalProperty]):
     view: str
     view_property: str | None
-    value_type: str | DataType | ViewEntity | DMSUnknownEntity
+    value_type: str | DataType | ViewEntity | PhysicalUnknownEntity
     name: str | None = None
     description: str | None = None
     connection: Literal["direct"] | ReverseConnectionEntity | EdgeEntity | str | None = None
@@ -129,7 +138,7 @@ class DMSInputProperty(UnverifiedComponent[DMSProperty]):
     index: str | list[str] | None = None
     constraint: str | list[str] | None = None
     neatId: str | URIRef | None = None
-    logical: str | URIRef | None = None
+    conceptual: str | URIRef | None = None
 
     @property
     def nullable(self) -> bool | None:
@@ -145,8 +154,8 @@ class DMSInputProperty(UnverifiedComponent[DMSProperty]):
         )
 
     @classmethod
-    def _get_verified_cls(cls) -> type[DMSProperty]:
-        return DMSProperty
+    def _get_verified_cls(cls) -> type[PhysicalProperty]:
+        return PhysicalProperty
 
     def dump(self, default_space: str, default_version: str) -> dict[str, Any]:  # type: ignore[override]
         output = super().dump()
@@ -206,7 +215,7 @@ class DMSInputProperty(UnverifiedComponent[DMSProperty]):
 
 
 @dataclass
-class DMSInputContainer(UnverifiedComponent[DMSContainer]):
+class UnverifiedPhysicalContainer(UnverifiedComponent[PhysicalContainer]):
     container: str
     name: str | None = None
     description: str | None = None
@@ -215,8 +224,8 @@ class DMSInputContainer(UnverifiedComponent[DMSContainer]):
     used_for: Literal["node", "edge", "all"] | None = None
 
     @classmethod
-    def _get_verified_cls(cls) -> type[DMSContainer]:
-        return DMSContainer
+    def _get_verified_cls(cls) -> type[PhysicalContainer]:
+        return PhysicalContainer
 
     def dump(self, default_space: str) -> dict[str, Any]:  # type: ignore[override]
         output = super().dump()
@@ -232,7 +241,7 @@ class DMSInputContainer(UnverifiedComponent[DMSContainer]):
         return ContainerEntity.load(self.container, strict=True, space=default_space)
 
     @classmethod
-    def from_container(cls, container: dm.ContainerApply) -> "DMSInputContainer":
+    def from_container(cls, container: dm.ContainerApply) -> "UnverifiedPhysicalContainer":
         constraints: list[str] = []
         for _, constraint_obj in (container.constraints or {}).items():
             if isinstance(constraint_obj, dm.RequiresConstraint):
@@ -249,7 +258,7 @@ class DMSInputContainer(UnverifiedComponent[DMSContainer]):
 
 
 @dataclass
-class DMSInputView(UnverifiedComponent[DMSView]):
+class UnverifiedPhysicalView(UnverifiedComponent[PhysicalView]):
     view: str
     name: str | None = None
     description: str | None = None
@@ -257,15 +266,15 @@ class DMSInputView(UnverifiedComponent[DMSView]):
     filter_: Literal["hasData", "nodeType", "rawFilter"] | str | None = None
     in_model: bool = True
     neatId: str | URIRef | None = None
-    logical: str | URIRef | None = None
+    conceptual: str | URIRef | None = None
 
     def __post_init__(self) -> None:
         if self.in_model is None:
             self.in_model = True
 
     @classmethod
-    def _get_verified_cls(cls) -> type[DMSView]:
-        return DMSView
+    def _get_verified_cls(cls) -> type[PhysicalView]:
+        return PhysicalView
 
     def dump(self, default_space: str, default_version: str) -> dict[str, Any]:  # type: ignore[override]
         output = super().dump()
@@ -292,7 +301,7 @@ class DMSInputView(UnverifiedComponent[DMSView]):
         return self._load_implements(default_space, default_version) or []
 
     @classmethod
-    def from_view(cls, view: dm.ViewApply, in_model: bool) -> "DMSInputView":
+    def from_view(cls, view: dm.ViewApply, in_model: bool) -> "UnverifiedPhysicalView":
         view_entity = ViewEntity.from_id(view.as_id())
 
         return cls(
@@ -307,7 +316,7 @@ class DMSInputView(UnverifiedComponent[DMSView]):
 
 
 @dataclass
-class DMSInputNode(UnverifiedComponent[DMSNode]):
+class UnverifiedPhysicalNodeType(UnverifiedComponent[PhysicalNodeType]):
     node: str
     usage: Literal["type", "collocation"]
     name: str | None = None
@@ -315,11 +324,11 @@ class DMSInputNode(UnverifiedComponent[DMSNode]):
     neatId: str | URIRef | None = None
 
     @classmethod
-    def _get_verified_cls(cls) -> type[DMSNode]:
-        return DMSNode
+    def _get_verified_cls(cls) -> type[PhysicalNodeType]:
+        return PhysicalNodeType
 
     @classmethod
-    def from_node_type(cls, node_type: dm.NodeApply) -> "DMSInputNode":
+    def from_node_type(cls, node_type: dm.NodeApply) -> "UnverifiedPhysicalNodeType":
         return cls(node=f"{node_type.space}:{node_type.external_id}", usage="type")
 
     def dump(self, default_space: str, **_) -> dict[str, Any]:  # type: ignore
@@ -329,7 +338,7 @@ class DMSInputNode(UnverifiedComponent[DMSNode]):
 
 
 @dataclass
-class DMSInputEnum(UnverifiedComponent[DMSEnum]):
+class UnverifiedPhysicalEnum(UnverifiedComponent[PhysicalEnum]):
     collection: str
     value: str
     name: str | None = None
@@ -337,22 +346,22 @@ class DMSInputEnum(UnverifiedComponent[DMSEnum]):
     neatId: str | URIRef | None = None
 
     @classmethod
-    def _get_verified_cls(cls) -> type[DMSEnum]:
-        return DMSEnum
+    def _get_verified_cls(cls) -> type[PhysicalEnum]:
+        return PhysicalEnum
 
 
 @dataclass
-class DMSInputRules(UnverifiedDataModel[DMSRules]):
-    metadata: DMSInputMetadata
-    properties: list[DMSInputProperty]
-    views: list[DMSInputView]
-    containers: list[DMSInputContainer] | None = None
-    enum: list[DMSInputEnum] | None = None
-    nodes: list[DMSInputNode] | None = None
+class UnverifiedPhysicalDataModel(UnverifiedDataModel[PhysicalDataModel]):
+    metadata: UnverifiedPhysicalMetadata
+    properties: list[UnverifiedPhysicalProperty]
+    views: list[UnverifiedPhysicalView]
+    containers: list[UnverifiedPhysicalContainer] | None = None
+    enum: list[UnverifiedPhysicalEnum] | None = None
+    nodes: list[UnverifiedPhysicalNodeType] | None = None
 
     @classmethod
-    def _get_verified_cls(cls) -> type[DMSRules]:
-        return DMSRules
+    def _get_verified_cls(cls) -> type[PhysicalDataModel]:
+        return PhysicalDataModel
 
     def dump(self) -> dict[str, Any]:
         default_space = self.metadata.space
@@ -369,7 +378,7 @@ class DMSInputRules(UnverifiedDataModel[DMSRules]):
 
     @classmethod
     def display_type_name(cls) -> str:
-        return "UnverifiedDMSModel"
+        return "UnverifiedPhysicalModel"
 
     @property
     def display_name(self) -> str:
@@ -378,7 +387,7 @@ class DMSInputRules(UnverifiedDataModel[DMSRules]):
     def _repr_html_(self) -> str:
         summary = {
             "type": "Physical Data Model",
-            "intended for": "DMS Architect",
+            "intended for": "Data Engineer",
             "name": self.metadata.name,
             "space": self.metadata.space,
             "external_id": self.metadata.external_id,