cognite-neat 0.99.0__py3-none-any.whl → 0.100.0__py3-none-any.whl

cognite/neat/_rules/models/dms/_exporter.py

@@ -1,7 +1,7 @@
 import warnings
 from collections import defaultdict
 from collections.abc import Collection, Hashable, Sequence
-from typing import Any
+from typing import Any, cast
 
 from cognite.client.data_classes import data_modeling as dm
 from cognite.client.data_classes.data_modeling.containers import BTreeIndex
@@ -20,7 +20,8 @@ from cognite.neat._client.data_classes.data_modeling import (
     ViewApplyDict,
 )
 from cognite.neat._client.data_classes.schema import DMSSchema
-from cognite.neat._issues.errors import NeatTypeError, ResourceNotFoundError
+from cognite.neat._constants import COGNITE_SPACES
+from cognite.neat._issues.errors import NeatTypeError, NeatValueError, ResourceNotFoundError
 from cognite.neat._issues.warnings import NotSupportedWarning, PropertyNotFoundWarning
 from cognite.neat._issues.warnings.user_modeling import (
     EmptyContainerWarning,
@@ -54,19 +55,13 @@ class _DMSExporter:
         include_pipeline (bool): If True, the pipeline will be included with the schema. Pipeline means the
             raw tables and transformations necessary to populate the data model.
         instance_space (str): The space to use for the instance. Defaults to None,`Rules.metadata.space` will be used
+        remove_cdf_spaces(bool): The
     """
 
-    def __init__(self, rules: DMSRules, instance_space: str | None = None):
+    def __init__(self, rules: DMSRules, instance_space: str | None = None, remove_cdf_spaces: bool = False):
         self.instance_space = instance_space
         self.rules = rules
-        self._ref_schema = None
-        if self._ref_schema:
-            # We skip version as that will always be missing in the reference
-            self._ref_views_by_id = {
-                dm.ViewId(view.space, view.external_id): view for view in self._ref_schema.views.values()
-            }
-        else:
-            self._ref_views_by_id = {}  # type: ignore
+        self.remove_cdf_spaces = remove_cdf_spaces
 
     def to_schema(self) -> DMSSchema:
         rules = self.rules
@@ -78,7 +73,7 @@ class _DMSExporter:
             view_properties_by_id, rules.views
         )
 
-        views = self._create_views_with_node_types(view_properties_by_id, view_properties_with_ancestors_by_id)
+        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:
             if isinstance(dms_view.filter_, NodeTypeFilter):
@@ -89,21 +84,22 @@ class _DMSExporter:
                 + [dm.NodeApply(node.space, node.external_id) for node in view_node_type_filters]
             )
         else:
-            node_types = NodeApplyDict([dm.NodeApply(node.space, node.external_id) for node in view_node_type_filters])
-
-        last_schema: DMSSchema | None = None
+            node_types = NodeApplyDict(
+                [
+                    dm.NodeApply(node.space, node.external_id)
+                    for node in view_node_type_filters
+                    if not (self.remove_cdf_spaces and node.space in COGNITE_SPACES)
+                ]
+            )
 
-        views_not_in_model = {view.view.as_id() for view in rules.views if not view.in_model}
         data_model = rules.metadata.as_data_model()
-
-        data_model_views = [view_id for view_id in views if view_id not in views_not_in_model]
-
         # Sorting to ensure deterministic order
-        data_model.views = sorted(data_model_views, key=lambda v: v.as_tuple())  # type: ignore[union-attr]
-
+        data_model.views = sorted(
+            [dms_view.view.as_id() for dms_view in rules.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)
-
-        output = DMSSchema(
+        return DMSSchema(
             spaces=spaces,
             data_model=data_model,
             views=views,
@@ -111,12 +107,6 @@ class _DMSExporter:
             node_types=node_types,
         )
 
-        if self._ref_schema:
-            output.reference = self._ref_schema
-        if last_schema:
-            output.last = last_schema
-        return output
-
     def _create_spaces(
         self,
         metadata: DMSMetadata,
@@ -136,21 +126,34 @@ class _DMSExporter:
             spaces[self.instance_space] = dm.SpaceApply(space=self.instance_space, name=self.instance_space)
         return spaces
 
-    def _create_views_with_node_types(
+    def _create_views(
         self,
         view_properties_by_id: dict[dm.ViewId, list[DMSProperty]],
         view_properties_with_ancestors_by_id: dict[dm.ViewId, list[DMSProperty]],
     ) -> ViewApplyDict:
         input_views = list(self.rules.views)
 
-        views = ViewApplyDict([dms_view.as_view() for dms_view in input_views])
+        views = ViewApplyDict(
+            [
+                dms_view.as_view()
+                for dms_view in input_views
+                if not (self.remove_cdf_spaces and dms_view.view.space in COGNITE_SPACES)
+            ]
+        )
+        view_by_id = {dms_view.view: dms_view for dms_view in input_views}
+
+        edge_types_by_view_property_id = self._edge_types_by_view_property_id(
+            view_properties_with_ancestors_by_id, view_by_id
+        )
 
         for view_id, view in views.items():
             view.properties = {}
             if not (view_properties := view_properties_by_id.get(view_id)):
                 continue
             for prop in view_properties:
-                view_property = self._create_view_property(prop, view_properties_with_ancestors_by_id)
+                view_property = self._create_view_property(
+                    prop, view_properties_with_ancestors_by_id, edge_types_by_view_property_id
+                )
                 if view_property is not None:
                     view.properties[prop.view_property] = view_property
 
@@ -161,18 +164,112 @@ class _DMSExporter:
         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):
-            return cls._create_edge_type_from_view_id(prop.view.as_id(), prop.view_property)
+            return cls._default_edge_type_from_view_id(prop.view.as_id(), prop.view_property)
         else:
             raise NeatTypeError(f"Invalid valueType {prop.value_type!r}")
 
     @staticmethod
-    def _create_edge_type_from_view_id(view_id: dm.ViewId, property_: str) -> dm.DirectRelationReference:
+    def _default_edge_type_from_view_id(view_id: dm.ViewId, property_: str) -> dm.DirectRelationReference:
         return dm.DirectRelationReference(
             space=view_id.space,
             # This is the same convention as used when converting GraphQL to DMS
             external_id=f"{view_id.external_id}.{property_}",
         )
 
+    @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],
+    ) -> dict[tuple[ViewEntity, str], dm.DirectRelationReference]:
+        edge_connection_property_by_view_property_id: dict[tuple[ViewEntity, str], DMSProperty] = {}
+        for properties in view_properties_with_ancestors_by_id.values():
+            for prop in properties:
+                if isinstance(prop.connection, EdgeEntity):
+                    view_property_id = (prop.view, prop.view_property)
+                    edge_connection_property_by_view_property_id[view_property_id] = prop
+
+        edge_types_by_view_property_id: dict[tuple[ViewEntity, str], dm.DirectRelationReference] = {}
+
+        outwards_type_by_view_value_type: dict[tuple[ViewEntity, ViewEntity], list[dm.DirectRelationReference]] = (
+            defaultdict(list)
+        )
+        # First set the edge types for outwards connections.
+        for (view_id, _), prop in edge_connection_property_by_view_property_id.items():
+            # We have already filtered out all non-EdgeEntity connections
+            connection = cast(EdgeEntity, prop.connection)
+            if connection.direction == "inwards":
+                continue
+            view = view_by_id[view_id]
+
+            edge_type = cls._get_edge_type_outwards_connection(
+                view, prop, view_by_id, edge_connection_property_by_view_property_id
+            )
+
+            edge_types_by_view_property_id[(prop.view, prop.view_property)] = edge_type
+
+            if isinstance(prop.value_type, ViewEntity):
+                outwards_type_by_view_value_type[(prop.value_type, prop.view)].append(edge_type)
+
+        # Then inwards connections = outwards connections
+        for (view_id, prop_id), prop in edge_connection_property_by_view_property_id.items():
+            # We have already filtered out all non-EdgeEntity connections
+            connection = cast(EdgeEntity, prop.connection)
+
+            if connection.direction == "inwards" and isinstance(prop.value_type, ViewEntity):
+                edge_type_candidates = outwards_type_by_view_value_type.get((prop.view, prop.value_type), [])
+                if len(edge_type_candidates) == 0:
+                    # Warning in validation, should not have an inwards connection without an outwards connection
+                    edge_type = cls._default_edge_type_from_view_id(prop.view.as_id(), prop_id)
+                elif len(edge_type_candidates) == 1:
+                    edge_type = edge_type_candidates[0]
+                else:
+                    raise NeatValueError(
+                        f"Cannot infer edge type for {view_id}.{prop_id}, multiple candidates: {edge_type_candidates}."
+                        "Please specify edge type explicitly, i.e., edge(type=<YOUR_TYPE>)."
+                    )
+                view_property_id = (prop.view, prop.view_property)
+                edge_types_by_view_property_id[view_property_id] = edge_type
+
+        return edge_types_by_view_property_id
+
+    @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],
+    ) -> dm.DirectRelationReference:
+        connection = cast(EdgeEntity, prop.connection)
+        if connection.edge_type is not None:
+            # Explicitly set edge type
+            return connection.edge_type.as_reference()
+        elif view.implements:
+            # Try to look for same property in parent views
+            candidates = []
+            for parent_id in view.implements:
+                if parent_view := view_by_id.get(parent_id):
+                    parent_prop = edge_connection_by_view_property_id.get((parent_view.view, prop.view_property))
+                    if parent_prop and isinstance(parent_prop.connection, EdgeEntity):
+                        parent_edge_type = cls._get_edge_type_outwards_connection(
+                            parent_view, parent_prop, view_by_id, edge_connection_by_view_property_id
+                        )
+                        candidates.append(parent_edge_type)
+            if len(candidates) == 0:
+                return cls._default_edge_type_from_view_id(prop.view.as_id(), prop.view_property)
+            elif len(candidates) == 1:
+                return candidates[0]
+            else:
+                raise NeatValueError(
+                    f"Cannot infer edge type for {prop.view.as_id()!r}.{prop.view_property}, "
+                    f"multiple candidates: {candidates}. "
+                    "Please specify edge type explicitly, i.e., edge(type=<YOUR_TYPE>)."
+                )
+        else:
+            # No parent view, use the default
+            return cls._default_edge_type_from_view_id(prop.view.as_id(), prop.view_property)
+
     def _create_containers(
         self,
         container_properties_by_id: dict[dm.ContainerId, list[DMSProperty]],
@@ -184,7 +281,13 @@ class _DMSExporter:
 
         containers = list(self.rules.containers or [])
 
-        containers = dm.ContainerApplyList([dms_container.as_container() for dms_container in containers])
+        containers = dm.ContainerApplyList(
+            [
+                dms_container.as_container()
+                for dms_container in containers
+                if not (self.remove_cdf_spaces and dms_container.container.space in COGNITE_SPACES)
+            ]
+        )
         container_to_drop = set()
         for container in containers:
             container_id = container.as_id()
@@ -371,106 +474,127 @@ class _DMSExporter:
 
     @classmethod
     def _create_view_property(
-        cls, prop: DMSProperty, view_properties_with_ancestors_by_id: dict[dm.ViewId, list[DMSProperty]]
+        cls,
+        prop: DMSProperty,
+        view_properties_with_ancestors_by_id: dict[dm.ViewId, list[DMSProperty]],
+        edge_types_by_view_property_id: dict[tuple[ViewEntity, str], dm.DirectRelationReference],
     ) -> ViewPropertyApply | None:
         if prop.container and prop.container_property:
-            container_prop_identifier = 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):
-                    extra_args["source"] = None
-                else:
-                    # Should have been validated.
-                    raise ValueError(
-                        "If this error occurs it is a bug in NEAT, please report"
-                        f"Debug Info, Invalid valueType direct: {prop.model_dump_json()}"
-                    )
-            elif prop.connection is not None:
-                # Should have been validated.
-                raise ValueError(
-                    "If this error occurs it is a bug in NEAT, please report"
-                    f"Debug Info, Invalid connection: {prop.model_dump_json()}"
-                )
-            return dm.MappedPropertyApply(
-                container=prop.container.as_id(),
-                container_property_identifier=container_prop_identifier,
-                name=prop.name,
-                description=prop.description,
-                **extra_args,
-            )
+            return cls._create_mapped_property(prop)
         elif isinstance(prop.connection, EdgeEntity):
-            if isinstance(prop.value_type, ViewEntity):
-                source_view_id = prop.value_type.as_id()
-            else:
-                # Should have been validated.
-                raise ValueError(
-                    "If this error occurs it is a bug in NEAT, please report"
-                    f"Debug Info, Invalid valueType edge: {prop.model_dump_json()}"
-                )
-            edge_source: dm.ViewId | None = None
-            if prop.connection.properties is not None:
-                edge_source = prop.connection.properties.as_id()
-            edge_cls: type[dm.EdgeConnectionApply] = dm.MultiEdgeConnectionApply
-            # If is_list is not set, we default to a MultiEdgeConnection
-            if prop.is_list is False:
-                edge_cls = SingleEdgeConnectionApply
-
-            return edge_cls(
-                type=cls._create_edge_type_from_prop(prop),
-                source=source_view_id,
-                direction=prop.connection.direction,
-                name=prop.name,
-                description=prop.description,
-                edge_source=edge_source,
-            )
+            return cls._create_edge_property(prop, edge_types_by_view_property_id)
         elif isinstance(prop.connection, ReverseConnectionEntity):
-            reverse_prop_id = prop.connection.property_
+            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
+            )
+        return None
+
+    @classmethod
+    def _create_mapped_property(cls, prop: DMSProperty) -> 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):
-                source_view_id = prop.value_type.as_id()
+                extra_args["source"] = prop.value_type.as_id()
+            elif isinstance(prop.value_type, DMSUnknownEntity):
+                extra_args["source"] = None
             else:
                 # Should have been validated.
                 raise ValueError(
                     "If this error occurs it is a bug in NEAT, please report"
-                    f"Debug Info, Invalid valueType reverse connection: {prop.model_dump_json()}"
+                    f"Debug Info, Invalid valueType direct: {prop.model_dump_json()}"
                 )
-            reverse_prop = next(
-                (
-                    prop
-                    for prop in view_properties_with_ancestors_by_id.get(source_view_id, [])
-                    if prop.view_property == reverse_prop_id
-                ),
-                None,
+        elif prop.connection is not None:
+            # Should have been validated.
+            raise ValueError(
+                "If this error occurs it is a bug in NEAT, please report"
+                f"Debug Info, Invalid connection: {prop.model_dump_json()}"
             )
-            if reverse_prop is None:
-                warnings.warn(
-                    PropertyNotFoundWarning(
-                        source_view_id,
-                        "view",
-                        reverse_prop_id or "MISSING",
-                        dm.PropertyId(prop.view.as_id(), prop.view_property),
-                        "view property",
-                    ),
-                    stacklevel=2,
-                )
+        return dm.MappedPropertyApply(
+            container=container.as_id(),
+            container_property_identifier=container_prop_identifier,
+            name=prop.name,
+            description=prop.description,
+            **extra_args,
+        )
 
-            if reverse_prop and reverse_prop.connection == "direct":
-                args: dict[str, Any] = dict(
-                    source=source_view_id,
-                    through=dm.PropertyId(source=source_view_id, property=reverse_prop_id),
-                    name=prop.name,
-                    description=prop.description,
-                )
-                if prop.is_list in [True, None]:
-                    return dm.MultiReverseDirectRelationApply(**args)
-                else:
-                    return SingleReverseDirectRelationApply(**args)
-            else:
-                return None
+    @classmethod
+    def _create_edge_property(
+        cls, prop: DMSProperty, 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):
+            source_view_id = prop.value_type.as_id()
+        else:
+            # Should have been validated.
+            raise ValueError(
+                "If this error occurs it is a bug in NEAT, please report"
+                f"Debug Info, Invalid valueType edge: {prop.model_dump_json()}"
+            )
+        edge_source: dm.ViewId | None = None
+        if connection.properties is not None:
+            edge_source = connection.properties.as_id()
+        edge_cls: type[dm.EdgeConnectionApply] = dm.MultiEdgeConnectionApply
+        # If is_list is not set, we default to a MultiEdgeConnection
+        if prop.is_list is False:
+            edge_cls = SingleEdgeConnectionApply
+
+        return edge_cls(
+            type=edge_types_by_view_property_id[(prop.view, prop.view_property)],
+            source=source_view_id,
+            direction=connection.direction,
+            name=prop.name,
+            description=prop.description,
+            edge_source=edge_source,
+        )
 
-        elif prop.view and prop.view_property and prop.connection:
+    @classmethod
+    def _create_reverse_direct_relation(
+        cls, prop: DMSProperty, view_properties_with_ancestors_by_id: dict[dm.ViewId, list[DMSProperty]]
+    ) -> dm.MultiReverseDirectRelationApply | SingleReverseDirectRelationApply | None:
+        connection = cast(ReverseConnectionEntity, prop.connection)
+        reverse_prop_id = connection.property_
+        if isinstance(prop.value_type, ViewEntity):
+            source_view_id = prop.value_type.as_id()
+        else:
+            # Should have been validated.
+            raise ValueError(
+                "If this error occurs it is a bug in NEAT, please report"
+                f"Debug Info, Invalid valueType reverse connection: {prop.model_dump_json()}"
+            )
+        reverse_prop = next(
+            (
+                prop
+                for prop in view_properties_with_ancestors_by_id.get(source_view_id, [])
+                if prop.view_property == reverse_prop_id
+            ),
+            None,
+        )
+        if reverse_prop is None:
             warnings.warn(
-                NotSupportedWarning(f"{prop.connection} in {prop.view.as_id()!r}.{prop.view_property}"), stacklevel=2
+                PropertyNotFoundWarning(
+                    source_view_id,
+                    "view",
+                    reverse_prop_id or "MISSING",
+                    dm.PropertyId(prop.view.as_id(), prop.view_property),
+                    "view property",
+                ),
+                stacklevel=2,
             )
-        return None
+
+        if reverse_prop and reverse_prop.connection == "direct":
+            args: dict[str, Any] = dict(
+                source=source_view_id,
+                through=dm.PropertyId(source=source_view_id, property=reverse_prop_id),
+                name=prop.name,
+                description=prop.description,
+            )
+            if prop.is_list in [True, None]:
+                return dm.MultiReverseDirectRelationApply(**args)
+            else:
+                return SingleReverseDirectRelationApply(**args)
+        else:
+            return None

cognite/neat/_rules/models/dms/_rules.py

@@ -4,13 +4,11 @@ from typing import Any, ClassVar, Literal
 
 import pandas as pd
 from cognite.client import data_modeling as dm
-from pydantic import Field, field_serializer, field_validator, model_validator
+from pydantic import Field, field_serializer, field_validator
 from pydantic_core.core_schema import SerializationInfo, ValidationInfo
-from rdflib import URIRef
 
 from cognite.neat._client.data_classes.schema import DMSSchema
 from cognite.neat._constants import COGNITE_SPACES
-from cognite.neat._issues import MultiValueError
 from cognite.neat._issues.errors import NeatValueError
 from cognite.neat._issues.warnings import (
     PrincipleMatchingSpaceAndVersionWarning,
@@ -31,6 +29,7 @@ from cognite.neat._rules.models._types import (
     ContainerEntityType,
     DmsPropertyType,
     StrListType,
+    URIRefType,
     ViewEntityType,
 )
 from cognite.neat._rules.models.data_types import DataType
@@ -55,7 +54,7 @@ _DEFAULT_VERSION = "1"
 class DMSMetadata(BaseMetadata):
     role: ClassVar[RoleTypes] = RoleTypes.dms
     aspect: ClassVar[DataModelAspect] = DataModelAspect.physical
-    logical: str | None = None
+    logical: URIRefType | None = None
 
     def as_space(self) -> dm.SpaceApply:
         return dm.SpaceApply(
@@ -109,7 +108,7 @@ class DMSProperty(SheetRow):
     container_property: DmsPropertyType | None = Field(None, alias="Container Property")
     index: StrListType | None = Field(None, alias="Index")
     constraint: StrListType | None = Field(None, alias="Constraint")
-    logical: URIRef | None = Field(
+    logical: URIRefType | None = Field(
         None,
         alias="Logical",
         description="Used to make connection between physical and logical data model aspect",
@@ -247,7 +246,7 @@ class DMSView(SheetRow):
     implements: ViewEntityList | None = Field(None, alias="Implements")
     filter_: HasDataFilter | NodeTypeFilter | RawFilter | None = Field(None, alias="Filter")
     in_model: bool = Field(True, alias="In Model")
-    logical: URIRef | None = Field(
+    logical: URIRefType | None = Field(
         None,
         alias="Logical",
         description="Used to make connection between physical and logical data model aspect",
@@ -339,9 +338,6 @@ class DMSRules(BaseRules):
     containers: SheetList[DMSContainer] | None = Field(None, alias="Containers")
     enum: SheetList[DMSEnum] | None = Field(None, alias="Enum")
     nodes: SheetList[DMSNode] | None = Field(None, alias="Nodes")
-    # This is a hack to allow the post_validation to be turned off when needed
-    # Will likely be moved completely out of the rules in the future
-    post_validate: bool = Field(default=True, exclude=True, repr=False)
 
     @field_validator("views")
     def matching_version_and_space(cls, value: SheetList[DMSView], info: ValidationInfo) -> SheetList[DMSView]:
@@ -374,23 +370,10 @@ class DMSRules(BaseRules):
                 )
         return value
 
-    @model_validator(mode="after")
-    def post_validation(self) -> "DMSRules":
-        from ._validation import DMSPostValidation
-
-        if not self.post_validate:
-            return self
-        issue_list = DMSPostValidation(self).validate()
-        if issue_list.warnings:
-            issue_list.trigger_warnings()
-        if issue_list.has_errors:
-            raise MultiValueError(issue_list.errors)
-        return self
-
-    def as_schema(self, include_pipeline: bool = False, instance_space: str | None = None) -> DMSSchema:
+    def as_schema(self, instance_space: str | None = None, remove_cdf_spaces: bool = False) -> DMSSchema:
         from ._exporter import _DMSExporter
 
-        return _DMSExporter(self, instance_space).to_schema()
+        return _DMSExporter(self, instance_space, remove_cdf_spaces=remove_cdf_spaces).to_schema()
 
     def _repr_html_(self) -> str:
         summary = {
@@ -406,28 +389,3 @@ class DMSRules(BaseRules):
         }
 
         return pd.DataFrame([summary]).T.rename(columns={0: ""})._repr_html_()  # type: ignore
-
-    def imported_views_and_containers_ids(
-        self, include_model_views_with_no_properties: bool = True
-    ) -> tuple[set[dm.ViewId], set[dm.ContainerId]]:
-        existing_views = {view.view for view in self.views}
-        imported_views: set[dm.ViewId] = set()
-        for view in self.views:
-            for parent in view.implements or []:
-                if parent not in existing_views:
-                    imported_views.add(parent.as_id())
-        existing_containers = {container.container for container in self.containers or []}
-        imported_containers: set[dm.ContainerId] = set()
-        view_with_properties: set[ViewEntity] = set()
-        for prop in self.properties:
-            if prop.container and prop.container not in existing_containers:
-                imported_containers.add(prop.container.as_id())
-            if prop.view not in existing_views:
-                imported_views.add(prop.view.as_id())
-            view_with_properties.add(prop.view)
-
-        if include_model_views_with_no_properties:
-            extra_views = existing_views - view_with_properties
-            imported_views.update({view.as_id() for view in extra_views})
-
-        return imported_views, imported_containers

cognite/neat/_rules/models/dms/_rules_input.py

@@ -35,7 +35,7 @@ class DMSInputMetadata(InputComponent[DMSMetadata]):
     description: str | None = None
     created: datetime | str | None = None
     updated: datetime | str | None = None
-    logical: str | None = None
+    logical: str | URIRef | None = None
 
     @classmethod
     def _get_verified_cls(cls) -> type[DMSMetadata]:
@@ -108,7 +108,8 @@ class DMSInputProperty(InputComponent[DMSProperty]):
     container_property: str | None = None
     index: str | list[str] | None = None
     constraint: str | list[str] | None = None
-    logical: str | None = None
+    neatId: str | URIRef | None = None
+    logical: str | URIRef | None = None
 
     @classmethod
     def _get_verified_cls(cls) -> type[DMSProperty]:
@@ -139,6 +140,7 @@ class DMSInputContainer(InputComponent[DMSContainer]):
     name: str | None = None
     description: str | None = None
     constraint: str | None = None
+    neatId: str | URIRef | None = None
     used_for: Literal["node", "edge", "all"] | None = None
 
     @classmethod
@@ -183,7 +185,8 @@ class DMSInputView(InputComponent[DMSView]):
     implements: str | None = None
     filter_: Literal["hasData", "nodeType", "rawFilter"] | str | None = None
     in_model: bool = True
-    logical: str | None = None
+    neatId: str | URIRef | None = None
+    logical: str | URIRef | None = None
 
     @classmethod
     def _get_verified_cls(cls) -> type[DMSView]:
@@ -231,6 +234,7 @@ class DMSInputNode(InputComponent[DMSNode]):
     usage: Literal["type", "collocation"]
     name: str | None = None
     description: str | None = None
+    neatId: str | URIRef | None = None
 
     @classmethod
     def _get_verified_cls(cls) -> type[DMSNode]:
@@ -252,6 +256,7 @@ class DMSInputEnum(InputComponent[DMSEnum]):
     value: str
     name: str | None = None
     description: str | None = None
+    neatId: str | URIRef | None = None
 
     @classmethod
     def _get_verified_cls(cls) -> type[DMSEnum]: