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

cognite/neat/_rules/importers/_dms2rules.py

@@ -4,7 +4,6 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Literal, cast
 
-from cognite.client import CogniteClient
 from cognite.client import data_modeling as dm
 from cognite.client.data_classes.data_modeling import DataModelId, DataModelIdentifier
 from cognite.client.data_classes.data_modeling.containers import BTreeIndex, InvertedIndex
@@ -19,6 +18,7 @@ from cognite.client.data_classes.data_modeling.views import (
 )
 from cognite.client.utils import ms_to_datetime
 
+from cognite.neat._client import NeatClient
 from cognite.neat._issues import IssueList, NeatIssue
 from cognite.neat._issues.errors import FileTypeUnexpectedError, ResourceMissingIdentifierError, ResourceRetrievalError
 from cognite.neat._issues.warnings import (
@@ -95,7 +95,7 @@ class DMSImporter(BaseImporter[DMSInputRules]):
     @classmethod
     def from_data_model_id(
         cls,
-        client: CogniteClient,
+        client: NeatClient,
         data_model_id: DataModelIdentifier,
         reference_model_id: DataModelIdentifier | None = None,
     ) -> "DMSImporter":
@@ -147,12 +147,12 @@ class DMSImporter(BaseImporter[DMSInputRules]):
 
         issue_list = IssueList()
         with _handle_issues(issue_list) as result:
-            schema = DMSSchema.from_data_model(client, user_model, ref_model)
+            schema = DMSSchema.from_data_model(NeatClient(client), user_model, ref_model)
 
         if result.result == "failure" or issue_list.has_errors:
             return cls(DMSSchema(), issue_list)
 
-        metadata = cls._create_metadata_from_model(user_model, has_reference=ref_model is not None)
+        metadata = cls._create_metadata_from_model(user_model)
         ref_metadata = cls._create_metadata_from_model(ref_model) if ref_model else None
 
         return cls(schema, issue_list, metadata, ref_metadata)
@@ -174,7 +174,6 @@ class DMSImporter(BaseImporter[DMSInputRules]):
     def _create_metadata_from_model(
         cls,
         model: dm.DataModel[dm.View] | dm.DataModelApply,
-        has_reference: bool = False,
     ) -> DMSInputMetadata:
         description, creator = DMSInputMetadata._get_description_and_creator(model.description)
 

cognite/neat/_rules/importers/_rdf/_inference2rules.py

@@ -1,6 +1,6 @@
 from collections import Counter, defaultdict
 from collections.abc import Mapping
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import ClassVar, cast
 
@@ -8,8 +8,7 @@ from cognite.client import data_modeling as dm
 from rdflib import RDF, Namespace, URIRef
 from rdflib import Literal as RdfLiteral
 
-from cognite.neat._constants import DEFAULT_NAMESPACE
-from cognite.neat._issues.warnings import PropertyValueTypeUndefinedWarning
+from cognite.neat._issues.warnings import PropertySkippedWarning, PropertyValueTypeUndefinedWarning
 from cognite.neat._rules.models import data_types
 from cognite.neat._rules.models.data_types import AnyURI
 from cognite.neat._rules.models.entities._single_value import UnknownEntity
@@ -156,9 +155,21 @@ class InferenceImporter(BaseRDFImporter):
                     # this is to skip rdf:type property
                     if property_uri == RDF.type:
                         continue
+                    property_id = remove_namespace_from_uri(property_uri)
+                    if property_id in {"external_id", "externalId"}:
+                        skip_issue = PropertySkippedWarning(
+                            resource_type="Property",
+                            identifier=f"{class_id}:{property_id}",
+                            property_name=property_id,
+                            reason="External ID is assumed to be the unique identifier of the instance "
+                            "and is not part of the data model schema.",
+                        )
+                        if skip_issue not in self.issue_list:
+                            self.issue_list.append(skip_issue)
+                        continue
 
                     self._add_uri_namespace_to_prefixes(cast(URIRef, property_uri), prefixes)
-                    property_id = remove_namespace_from_uri(property_uri)
+
                     if isinstance(data_type_uri, URIRef):
                         data_type_uri = self.overwrite_data_types.get(data_type_uri, data_type_uri)
 
@@ -198,11 +209,12 @@ class InferenceImporter(BaseRDFImporter):
 
                     # USE CASE 1: If property is not present in properties
                     if id_ not in properties:
+                        definition["value_type"] = {definition["value_type"]}
                         properties[id_] = definition
 
                     # USE CASE 2: first time redefinition, value type change to multi
                     elif id_ in properties and definition["value_type"] not in properties[id_]["value_type"]:
-                        properties[id_]["value_type"] = properties[id_]["value_type"] + " | " + definition["value_type"]
+                        properties[id_]["value_type"].add(definition["value_type"])
 
                     # USE CASE 3: existing but max count is different
                     elif (
@@ -212,32 +224,12 @@ class InferenceImporter(BaseRDFImporter):
                     ):
                         properties[id_]["max_count"] = max(properties[id_]["max_count"], definition["max_count"])
 
-        # Add comments
-        for id_, property_ in properties.items():
-            if id_ not in count_by_value_type_by_property:
-                continue
-
-            count_by_value_type = count_by_value_type_by_property[id_]
-            count_list = sorted(count_by_value_type.items(), key=lambda item: item[1], reverse=True)
-            # Make the comment more readable by adapting to the number of value types
-            base_string = "<{value_type}> which occurs <{count}> times"
-            if len(count_list) == 1:
-                type_, count = count_list[0]
-                counts_str = f"with value type {base_string.format(value_type=type_, count=count)} in the graph"
-            elif len(count_list) == 2:
-                first = base_string.format(value_type=count_list[0][0], count=count_list[0][1])
-                second = base_string.format(value_type=count_list[1][0], count=count_list[1][1])
-                counts_str = f"with value types {first} and {second} in the graph"
+        # Create multi-value properties otherwise single value
+        for property_ in properties.values():
+            if len(property_["value_type"]) > 1:
+                property_["value_type"] = " | ".join([str(t) for t in property_["value_type"]])
             else:
-                first_part = ", ".join(
-                    base_string.format(value_type=type_, count=count) for type_, count in count_list[:-1]
-                )
-                last = base_string.format(value_type=count_list[-1][0], count=count_list[-1][1])
-                counts_str = f"with value types {first_part} and {last} in the graph"
-
-            class_id = property_["class_"]
-            property_id = property_["property_"]
-            property_["comment"] = f"Class <{class_id}> has property <{property_id}> {counts_str}"
+                property_["value_type"] = next(iter(property_["value_type"]))
 
         return {
             "metadata": self._default_metadata().model_dump(),
@@ -247,14 +239,14 @@ class InferenceImporter(BaseRDFImporter):
         }
 
     def _default_metadata(self):
+        now = datetime.now(timezone.utc)
         return InformationMetadata(
             space=self.data_model_id.space,
             external_id=self.data_model_id.external_id,
             version=self.data_model_id.version,
             name="Inferred Model",
             creator="NEAT",
-            created=datetime.now(),
-            updated=datetime.now(),
+            created=now,
+            updated=now,
             description="Inferred model from knowledge graph",
-            namespace=DEFAULT_NAMESPACE,
         )

cognite/neat/_rules/models/__init__.py

@@ -1,10 +1,10 @@
+from cognite.neat._client.data_classes.schema import DMSSchema
 from cognite.neat._rules.models.information._rules import InformationRules
 from cognite.neat._rules.models.information._rules_input import InformationInputRules
 
 from ._base_rules import DataModelType, ExtensionCategory, RoleTypes, SchemaCompleteness, SheetList, SheetRow
 from .dms._rules import DMSRules
 from .dms._rules_input import DMSInputRules
-from .dms._schema import DMSSchema
 
 INPUT_RULES_BY_ROLE: dict[RoleTypes, type[InformationInputRules] | type[DMSInputRules]] = {
     RoleTypes.information: InformationInputRules,

cognite/neat/_rules/models/_base_rules.py

@@ -2,8 +2,6 @@
 its sub-models and validators.
 """
 
-from __future__ import annotations
-
 import math
 import sys
 import types
@@ -39,13 +37,16 @@ from rdflib import Namespace, URIRef
 
 from cognite.neat._constants import DEFAULT_NAMESPACE
 from cognite.neat._rules.models._types import (
-    ClassEntityType,
+    ContainerEntityType,
     DataModelExternalIdType,
-    InformationPropertyType,
+    DmsPropertyType,
     SpaceType,
     StrListType,
     VersionType,
+    ViewEntityType,
 )
+from cognite.neat._rules.models.data_types import DataType
+from cognite.neat._rules.models.entities import EdgeEntity, ReverseConnectionEntity, ViewEntity
 
 if sys.version_info >= (3, 11):
     from enum import StrEnum
@@ -249,7 +250,7 @@ class BaseRules(SchemaModel, ABC):
         """Returns a list of headers for the model, typically used by ExcelExporter"""
         headers_by_sheet: dict[str, list[str]] = {}
         for field_name, field in cls.model_fields.items():
-            if field_name == "validators_to_skip":
+            if field_name in ["validators_to_skip", "post_validate"]:
                 continue
             sheet_name = (field.alias or field_name) if by_alias else field_name
             annotation = field.annotation
@@ -379,9 +380,9 @@ class SheetList(list, MutableSequence[T_SheetRow]):
     def __getitem__(self, index: SupportsIndex) -> T_SheetRow: ...
 
     @overload
-    def __getitem__(self, index: slice) -> SheetList[T_SheetRow]: ...
+    def __getitem__(self, index: slice) -> "SheetList[T_SheetRow]": ...
 
-    def __getitem__(self, index: SupportsIndex | slice, /) -> T_SheetRow | SheetList[T_SheetRow]:
+    def __getitem__(self, index: SupportsIndex | slice, /) -> "T_SheetRow | SheetList[T_SheetRow]":
         if isinstance(index, slice):
             return SheetList[T_SheetRow](super().__getitem__(index))
         return super().__getitem__(index)
@@ -399,10 +400,19 @@ ExtensionCategoryType = Annotated[
 
 
 # Immutable such that this can be used as a key in a dictionary
-class PropertyRef(BaseModel, frozen=True):
-    class_: ClassEntityType = Field(alias="Class")
-    property_: InformationPropertyType = Field(alias="Property")
+class ContainerProperty(BaseModel, frozen=True):
+    container: ContainerEntityType
+    property_: DmsPropertyType
+
+
+class ContainerDestinationProperty(ContainerProperty, frozen=True):
+    value_type: DataType | ViewEntity
+    connection: Literal["direct"] | ReverseConnectionEntity | EdgeEntity | None = None
+
+
+class ViewRef(BaseModel, frozen=True):
+    view: ViewEntityType
 
 
-class ClassRef(BaseModel, frozen=True):
-    class_: ClassEntityType = Field(alias="Class")
+class ViewProperty(ViewRef, frozen=True):
+    property_: DmsPropertyType

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

@@ -1,3 +1,5 @@
+from cognite.neat._client.data_classes.schema import DMSSchema
+
 from ._rules import DMSContainer, DMSEnum, DMSMetadata, DMSNode, DMSProperty, DMSRules, DMSView
 from ._rules_input import (
     DMSInputContainer,
@@ -8,7 +10,6 @@ from ._rules_input import (
     DMSInputRules,
     DMSInputView,
 )
-from ._schema import DMSSchema, PipelineSchema
 
 __all__ = [
     "DMSRules",
@@ -19,7 +20,6 @@ __all__ = [
     "DMSContainer",
     "DMSNode",
     "DMSEnum",
-    "PipelineSchema",
     "DMSInputRules",
     "DMSInputMetadata",
     "DMSInputView",

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

@@ -13,6 +13,13 @@ from cognite.client.data_classes.data_modeling.views import (
     ViewPropertyApply,
 )
 
+from cognite.neat._client.data_classes.data_modeling import (
+    ContainerApplyDict,
+    NodeApplyDict,
+    SpaceApplyDict,
+    ViewApplyDict,
+)
+from cognite.neat._client.data_classes.schema import DMSSchema
 from cognite.neat._issues.errors import NeatTypeError, ResourceNotFoundError
 from cognite.neat._issues.warnings import NotSupportedWarning, PropertyNotFoundWarning
 from cognite.neat._issues.warnings.user_modeling import (
@@ -33,10 +40,8 @@ from cognite.neat._rules.models.entities import (
     UnitEntity,
     ViewEntity,
 )
-from cognite.neat._utils.cdf.data_classes import ContainerApplyDict, NodeApplyDict, SpaceApplyDict, ViewApplyDict
 
 from ._rules import DMSEnum, DMSMetadata, DMSProperty, DMSRules, DMSView
-from ._schema import DMSSchema, PipelineSchema
 
 
 class _DMSExporter:
@@ -51,13 +56,7 @@ class _DMSExporter:
         instance_space (str): The space to use for the instance. Defaults to None,`Rules.metadata.space` will be used
     """
 
-    def __init__(
-        self,
-        rules: DMSRules,
-        include_pipeline: bool = False,
-        instance_space: str | None = None,
-    ):
-        self.include_pipeline = include_pipeline
+    def __init__(self, rules: DMSRules, instance_space: str | None = None):
         self.instance_space = instance_space
         self.rules = rules
         self._ref_schema = None
@@ -79,9 +78,11 @@ class _DMSExporter:
             view_properties_by_id, rules.views
         )
 
-        views, view_node_type_filters = self._create_views_with_node_types(
-            view_properties_by_id, view_properties_with_ancestors_by_id
-        )
+        views = self._create_views_with_node_types(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):
+                view_node_type_filters.update(node.as_id() for node in dms_view.filter_.inner or [])
         if rules.nodes:
             node_types = NodeApplyDict(
                 [node.as_node() for node in rules.nodes]
@@ -109,8 +110,6 @@ class _DMSExporter:
             containers=containers,
             node_types=node_types,
         )
-        if self.include_pipeline:
-            return PipelineSchema.from_dms(output, self.instance_space)
 
         if self._ref_schema:
             output.reference = self._ref_schema
@@ -141,7 +140,7 @@ class _DMSExporter:
         self,
         view_properties_by_id: dict[dm.ViewId, list[DMSProperty]],
         view_properties_with_ancestors_by_id: dict[dm.ViewId, list[DMSProperty]],
-    ) -> tuple[ViewApplyDict, set[dm.NodeId]]:
+    ) -> ViewApplyDict:
         input_views = list(self.rules.views)
 
         views = ViewApplyDict([dms_view.as_view() for dms_view in input_views])
@@ -155,11 +154,7 @@ class _DMSExporter:
                 if view_property is not None:
                     view.properties[prop.view_property] = view_property
 
-        unique_node_types: set[dm.NodeId] = set()
-        for view in views.values():
-            unique_node_types.add(dm.NodeId(space=view.space, external_id=view.external_id))
-
-        return views, unique_node_types
+        return views
 
     @classmethod
     def _create_edge_type_from_prop(cls, prop: DMSProperty) -> dm.DirectRelationReference:

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

@@ -8,18 +8,23 @@ from pydantic import Field, field_serializer, field_validator, model_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,
 )
 from cognite.neat._rules.models._base_rules import (
     BaseMetadata,
     BaseRules,
+    ContainerProperty,
     DataModelAspect,
     RoleTypes,
     SheetList,
     SheetRow,
+    ViewProperty,
+    ViewRef,
 )
 from cognite.neat._rules.models._types import (
     ClassEntityType,
@@ -44,8 +49,6 @@ from cognite.neat._rules.models.entities import (
     ViewEntityList,
 )
 
-from ._schema import DMSSchema
-
 _DEFAULT_VERSION = "1"
 
 
@@ -180,6 +183,14 @@ class DMSProperty(SheetRow):
             return value.dump(space=metadata.space, version=metadata.version, type=default_type)
         return str(value)
 
+    def as_container_reference(self) -> ContainerProperty:
+        if self.container is None or self.container_property is None:
+            raise NeatValueError("Accessing container reference without container and container property set")
+        return ContainerProperty(container=self.container, property_=self.container_property)
+
+    def as_view_reference(self) -> ViewProperty:
+        return ViewProperty(view=self.view, property_=self.view_property)
+
 
 class DMSContainer(SheetRow):
     container: ContainerEntityType = Field(alias="Container")
@@ -272,10 +283,14 @@ class DMSView(SheetRow):
             version=view_id.version or _DEFAULT_VERSION,
             name=self.name or None,
             description=self.description,
+            filter=None if self.filter_ is None else self.filter_.as_dms_filter(),
             implements=implements,
             properties={},
         )
 
+    def as_view_reference(self) -> ViewRef:
+        return ViewRef(view=self.view)
+
 
 class DMSNode(SheetRow):
     node: DMSNodeEntity = Field(alias="Node")
@@ -324,6 +339,9 @@ 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]:
@@ -360,6 +378,8 @@ class DMSRules(BaseRules):
     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()
@@ -370,7 +390,7 @@ class DMSRules(BaseRules):
     def as_schema(self, include_pipeline: bool = False, instance_space: str | None = None) -> DMSSchema:
         from ._exporter import _DMSExporter
 
-        return _DMSExporter(self, include_pipeline, instance_space).to_schema()
+        return _DMSExporter(self, instance_space).to_schema()
 
     def _repr_html_(self) -> str:
         summary = {
@@ -386,3 +406,28 @@ 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

@@ -5,6 +5,7 @@ from typing import Any, Literal
 
 import pandas as pd
 from cognite.client import data_modeling as dm
+from cognite.client.data_classes.data_modeling import ContainerId, ViewId
 from rdflib import Namespace, URIRef
 
 from cognite.neat._constants import DEFAULT_NAMESPACE
@@ -125,6 +126,12 @@ class DMSInputProperty(InputComponent[DMSProperty]):
         )
         return output
 
+    def referenced_view(self, default_space: str, default_version: str) -> ViewEntity:
+        return ViewEntity.load(self.view, strict=True, space=default_space, version=default_version)
+
+    def referenced_container(self, default_space: str) -> ContainerEntity | None:
+        return ContainerEntity.load(self.container, strict=True, space=default_space) if self.container else None
+
 
 @dataclass
 class DMSInputContainer(InputComponent[DMSContainer]):
@@ -140,8 +147,7 @@ class DMSInputContainer(InputComponent[DMSContainer]):
 
     def dump(self, default_space: str) -> dict[str, Any]:  # type: ignore[override]
         output = super().dump()
-        container = ContainerEntity.load(self.container, space=default_space)
-        output["Container"] = container
+        output["Container"] = self.as_entity_id(default_space)
         output["Constraint"] = (
             [ContainerEntity.load(constraint.strip(), space=default_space) for constraint in self.constraint.split(",")]
             if self.constraint
@@ -149,6 +155,9 @@ class DMSInputContainer(InputComponent[DMSContainer]):
         )
         return output
 
+    def as_entity_id(self, default_space: str) -> ContainerEntity:
+        return ContainerEntity.load(self.container, strict=True, space=default_space)
+
     @classmethod
     def from_container(cls, container: dm.ContainerApply) -> "DMSInputContainer":
         constraints: list[str] = []
@@ -172,7 +181,7 @@ class DMSInputView(InputComponent[DMSView]):
     name: str | None = None
     description: str | None = None
     implements: str | None = None
-    filter_: Literal["hasData", "nodeType", "rawFilter"] | None = None
+    filter_: Literal["hasData", "nodeType", "rawFilter"] | str | None = None
     in_model: bool = True
     logical: str | None = None
 
@@ -182,17 +191,25 @@ class DMSInputView(InputComponent[DMSView]):
 
     def dump(self, default_space: str, default_version: str) -> dict[str, Any]:  # type: ignore[override]
         output = super().dump()
-        view = ViewEntity.load(self.view, space=default_space, version=default_version)
-        output["View"] = view
-        output["Implements"] = (
+        output["View"] = self.as_entity_id(default_space, default_version)
+        output["Implements"] = self._load_implements(default_space, default_version)
+        return output
+
+    def as_entity_id(self, default_space: str, default_version: str) -> ViewEntity:
+        return ViewEntity.load(self.view, strict=True, space=default_space, version=default_version)
+
+    def _load_implements(self, default_space: str, default_version: str) -> list[ViewEntity] | None:
+        return (
             [
-                ViewEntity.load(implement, space=default_space, version=default_version)
+                ViewEntity.load(implement, strict=True, space=default_space, version=default_version)
                 for implement in self.implements.split(",")
             ]
             if self.implements
             else None
         )
-        return output
+
+    def referenced_views(self, default_space: str, default_version: str) -> list[ViewEntity]:
+        return self._load_implements(default_space, default_version) or []
 
     @classmethod
     def from_view(cls, view: dm.ViewApply, in_model: bool) -> "DMSInputView":
@@ -287,3 +304,30 @@ class DMSInputRules(InputRules[DMSRules]):
         return DEFAULT_NAMESPACE[
             f"data-model/unverified/dms/{self.metadata.space}/{self.metadata.external_id}/{self.metadata.version}"
         ]
+
+    def referenced_views_and_containers(self) -> tuple[set[ViewEntity], set[ContainerEntity]]:
+        default_space = self.metadata.space
+        default_version = self.metadata.version
+
+        containers: set[ContainerEntity] = set()
+        views = {parent for view in self.views for parent in view.referenced_views(default_space, default_version)}
+        for prop in self.properties:
+            views.add(prop.referenced_view(default_space, default_version))
+            if ref_container := prop.referenced_container(default_space):
+                containers.add(ref_container)
+
+        return views, containers
+
+    def as_view_entities(self) -> list[ViewEntity]:
+        return [view.as_entity_id(self.metadata.space, self.metadata.version) for view in self.views]
+
+    def as_container_entities(self) -> list[ContainerEntity]:
+        return [container.as_entity_id(self.metadata.space) for container in self.containers or []]
+
+    def imported_views_and_containers(self) -> tuple[set[ViewEntity], set[ContainerEntity]]:
+        views, containers = self.referenced_views_and_containers()
+        return views - set(self.as_view_entities()), containers - set(self.as_container_entities())
+
+    def imported_views_and_containers_ids(self) -> tuple[set[ViewId], set[ContainerId]]:
+        views, containers = self.imported_views_and_containers()
+        return {view.as_id() for view in views}, {container.as_id() for container in containers}

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

@@ -3,6 +3,7 @@ from typing import Any, ClassVar, cast
 
 from cognite.client import data_modeling as dm
 
+from cognite.neat._client.data_classes.schema import DMSSchema
 from cognite.neat._constants import COGNITE_MODELS, DMS_CONTAINER_PROPERTY_SIZE_LIMIT
 from cognite.neat._issues import IssueList, NeatError, NeatIssue, NeatIssueList
 from cognite.neat._issues.errors import (
@@ -19,6 +20,7 @@ from cognite.neat._issues.warnings.user_modeling import (
     NotNeatSupportedFilterWarning,
     ViewPropertyLimitWarning,
 )
+from cognite.neat._rules.analysis import DMSAnalysis
 from cognite.neat._rules.models.data_types import DataType
 from cognite.neat._rules.models.entities import ContainerEntity, RawFilter
 from cognite.neat._rules.models.entities._single_value import (
@@ -27,7 +29,6 @@ from cognite.neat._rules.models.entities._single_value import (
 )
 
 from ._rules import DMSProperty, DMSRules
-from ._schema import DMSSchema
 
 
 class DMSPostValidation:
@@ -45,6 +46,7 @@ class DMSPostValidation:
         self.containers = rules.containers
         self.views = rules.views
         self.issue_list = IssueList()
+        self.probe = DMSAnalysis(rules)
 
     def validate(self) -> NeatIssueList:
         self._validate_raw_filter()
@@ -164,7 +166,7 @@ class DMSPostValidation:
             view_id = prop.view.as_id()
             if view_id not in defined_views:
                 errors.append(
-                    ResourceNotDefinedError[dm.ViewId](
+                    ResourceNotDefinedError(
                         identifier=view_id,
                         resource_type="view",
                         location="Views Sheet",
@@ -229,7 +231,12 @@ class DMSPostValidation:
         if self.metadata.as_data_model_id() in COGNITE_MODELS:
             return None
 
-        properties_by_ids = {f"{prop_.view!s}.{prop_.view_property}": prop_ for prop_ in self.properties}
+        properties_by_ids = {
+            f"{prop_.view!s}.{prop_.view_property}": prop_
+            for properties in self.probe.classes_with_properties(True, True).values()
+            for prop_ in properties
+        }
+
         reversed_by_ids = {
             id_: prop_
             for id_, prop_ in properties_by_ids.items()
@@ -239,7 +246,6 @@ class DMSPostValidation:
         for id_, prop_ in reversed_by_ids.items():
             source_id = f"{prop_.value_type!s}." f"{cast(ReverseConnectionEntity, prop_.connection).property_}"
             if source_id not in properties_by_ids:
-                print(f"source_id: {source_id}, first issue")
                 self.issue_list.append(
                     ReversedConnectionNotFeasibleError(
                         id_,
@@ -252,7 +258,6 @@ class DMSPostValidation:
                 )
 
             elif source_id in properties_by_ids and properties_by_ids[source_id].value_type != prop_.view:
-                print(f"source_id: {source_id}, second issue")
                 self.issue_list.append(
                     ReversedConnectionNotFeasibleError(
                         id_,