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

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

@@ -25,6 +25,20 @@ from cognite.neat.core._constants import (
     DMS_DIRECT_RELATION_LIST_DEFAULT_LIMIT,
     DMS_PRIMITIVE_LIST_DEFAULT_LIMIT,
 )
+from cognite.neat.core._data_model.models.data_types import DataType, Double, Enum, Float
+from cognite.neat.core._data_model.models.entities import (
+    ConceptEntity,
+    ContainerEntity,
+    DMSFilter,
+    DMSNodeEntity,
+    EdgeEntity,
+    HasDataFilter,
+    NodeTypeFilter,
+    PhysicalUnknownEntity,
+    ReverseConnectionEntity,
+    UnitEntity,
+    ViewEntity,
+)
 from cognite.neat.core._issues.errors import (
     NeatTypeError,
     NeatValueError,
@@ -38,22 +52,14 @@ from cognite.neat.core._issues.warnings.user_modeling import (
     EmptyContainerWarning,
     HasDataFilterOnNoPropertiesViewWarning,
 )
-from cognite.neat.core._rules.models.data_types import DataType, Double, Enum, Float
-from cognite.neat.core._rules.models.entities import (
-    ClassEntity,
-    ContainerEntity,
-    DMSFilter,
-    DMSNodeEntity,
-    DMSUnknownEntity,
-    EdgeEntity,
-    HasDataFilter,
-    NodeTypeFilter,
-    ReverseConnectionEntity,
-    UnitEntity,
-    ViewEntity,
-)
 
-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/{_rules/models/dms/_rules_input.py → _data_model/models/physical/_unverified.py}

@@ -14,23 +14,35 @@ from cognite.neat.core._constants import (
     DEFAULT_NAMESPACE,
     DMS_DIRECT_RELATION_LIST_DEFAULT_LIMIT,
 )
-from cognite.neat.core._issues.warnings import DeprecatedWarning
-from cognite.neat.core._rules.models._base_input import InputComponent, InputRules
-from cognite.neat.core._rules.models.data_types import DataType
-from cognite.neat.core._rules.models.entities import (
+from cognite.neat.core._data_model.models._base_unverified import (
+    UnverifiedComponent,
+    UnverifiedDataModel,
+)
+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,
     load_dms_value_type,
 )
-from cognite.neat.core._rules.models.entities._wrapped import DMSFilter
+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
@@ -39,7 +51,7 @@ else:
 
 
 @dataclass
-class DMSInputMetadata(InputComponent[DMSMetadata]):
+class UnverifiedPhysicalMetadata(UnverifiedComponent[PhysicalMetadata]):
     space: str
     external_id: str
     creator: str
@@ -48,12 +60,12 @@ class DMSInputMetadata(InputComponent[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()
@@ -64,7 +76,7 @@ class DMSInputMetadata(InputComponent[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,
@@ -110,10 +122,10 @@ class DMSInputMetadata(InputComponent[DMSMetadata]):
 
 
 @dataclass
-class DMSInputProperty(InputComponent[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
@@ -126,7 +138,7 @@ class DMSInputProperty(InputComponent[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:
@@ -142,8 +154,8 @@ class DMSInputProperty(InputComponent[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()
@@ -203,7 +215,7 @@ class DMSInputProperty(InputComponent[DMSProperty]):
 
 
 @dataclass
-class DMSInputContainer(InputComponent[DMSContainer]):
+class UnverifiedPhysicalContainer(UnverifiedComponent[PhysicalContainer]):
     container: str
     name: str | None = None
     description: str | None = None
@@ -212,8 +224,8 @@ class DMSInputContainer(InputComponent[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()
@@ -229,7 +241,7 @@ class DMSInputContainer(InputComponent[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):
@@ -246,7 +258,7 @@ class DMSInputContainer(InputComponent[DMSContainer]):
 
 
 @dataclass
-class DMSInputView(InputComponent[DMSView]):
+class UnverifiedPhysicalView(UnverifiedComponent[PhysicalView]):
     view: str
     name: str | None = None
     description: str | None = None
@@ -254,15 +266,15 @@ class DMSInputView(InputComponent[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()
@@ -289,7 +301,7 @@ class DMSInputView(InputComponent[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(
@@ -304,7 +316,7 @@ class DMSInputView(InputComponent[DMSView]):
 
 
 @dataclass
-class DMSInputNode(InputComponent[DMSNode]):
+class UnverifiedPhysicalNodeType(UnverifiedComponent[PhysicalNodeType]):
     node: str
     usage: Literal["type", "collocation"]
     name: str | None = None
@@ -312,11 +324,11 @@ class DMSInputNode(InputComponent[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
@@ -326,7 +338,7 @@ class DMSInputNode(InputComponent[DMSNode]):
 
 
 @dataclass
-class DMSInputEnum(InputComponent[DMSEnum]):
+class UnverifiedPhysicalEnum(UnverifiedComponent[PhysicalEnum]):
     collection: str
     value: str
     name: str | None = None
@@ -334,22 +346,22 @@ class DMSInputEnum(InputComponent[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(InputRules[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
@@ -366,7 +378,7 @@ class DMSInputRules(InputRules[DMSRules]):
 
     @classmethod
     def display_type_name(cls) -> str:
-        return "UnverifiedDMSModel"
+        return "UnverifiedPhysicalModel"
 
     @property
     def display_name(self) -> str:
@@ -375,7 +387,7 @@ class DMSInputRules(InputRules[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,

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

@@ -21,6 +21,11 @@ from cognite.neat.core._constants import (
     DMS_CONTAINER_PROPERTY_SIZE_LIMIT,
     DMS_VIEW_CONTAINER_SIZE_LIMIT,
 )
+from cognite.neat.core._data_model.models.data_types import DataType
+from cognite.neat.core._data_model.models.entities import ContainerEntity, RawFilter
+from cognite.neat.core._data_model.models.entities._single_value import (
+    ViewEntity,
+)
 from cognite.neat.core._issues import IssueList, NeatError
 from cognite.neat.core._issues.errors import (
     CDFMissingClientError,
@@ -35,6 +40,7 @@ from cognite.neat.core._issues.errors._external import CDFMissingResourcesError
 from cognite.neat.core._issues.warnings import (
     NotSupportedHasDataFilterLimitWarning,
     NotSupportedViewContainerLimitWarning,
+    ReversedConnectionNotFeasibleWarning,
     UndefinedViewWarning,
     user_modeling,
 )
@@ -43,33 +49,28 @@ from cognite.neat.core._issues.warnings.user_modeling import (
     DirectRelationMissingSourceWarning,
     NotNeatSupportedFilterWarning,
 )
-from cognite.neat.core._rules.models.data_types import DataType
-from cognite.neat.core._rules.models.entities import ContainerEntity, RawFilter
-from cognite.neat.core._rules.models.entities._single_value import (
-    ViewEntity,
-)
 from cognite.neat.core._utils.spreadsheet import SpreadsheetRead
 from cognite.neat.core._utils.text import humanize_collection
 
-from ._rules import DMSProperty, DMSRules
+from ._verified import PhysicalDataModel, PhysicalProperty
 
 
-class DMSValidation:
-    """This class does all the validation of the DMS rules that have dependencies between
-    components."""
+class PhysicalValidation:
+    """This class does all the validation of the physical data model that
+    have dependencies between components."""
 
     def __init__(
         self,
-        rules: DMSRules,
+        data_model: PhysicalDataModel,
         client: NeatClient | None = None,
         read_info_by_spreadsheet: dict[str, SpreadsheetRead] | None = None,
     ) -> None:
-        self._rules = rules
+        self._rules = data_model
         self._client = client
-        self._metadata = rules.metadata
-        self._properties = rules.properties
-        self._containers = rules.containers
-        self._views = rules.views
+        self._metadata = data_model.metadata
+        self._properties = data_model.properties
+        self._containers = data_model.containers
+        self._views = data_model.views
         self._read_info_by_spreadsheet = read_info_by_spreadsheet or {}
 
     def imported_views_and_containers_ids(
@@ -320,7 +321,9 @@ class DMSValidation:
         return parents_by_view
 
     def _consistent_container_properties(self) -> IssueList:
-        container_properties_by_id: dict[tuple[ContainerEntity, str], list[tuple[int, DMSProperty]]] = defaultdict(list)
+        container_properties_by_id: dict[tuple[ContainerEntity, str], list[tuple[int, PhysicalProperty]]] = defaultdict(
+            list
+        )
         for prop_no, prop in enumerate(self._properties):
             if prop.container and prop.container_property:
                 container_properties_by_id[(prop.container, prop.container_property)].append((prop_no, prop))
@@ -589,7 +592,7 @@ class DMSValidation:
                 )
             ):
                 issue_list.append(
-                    ReversedConnectionNotFeasibleError(
+                    ReversedConnectionNotFeasibleWarning(
                         view_id,
                         "reversed connection",
                         prop_id,