cognite-neat 0.99.1__py3-none-any.whl → 0.100.1__py3-none-any.whl

cognite/neat/_rules/models/_types.py

@@ -73,6 +73,11 @@ NamespaceType = Annotated[
     ),
 ]
 
+URIRefType = Annotated[
+    rdflib.URIRef,
+    BeforeValidator(lambda value: rdflib.URIRef(value)),
+]
+
 PrefixType = Annotated[
     str,
     StringConstraints(pattern=PREFIX_COMPLIANCE_REGEX),

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
@@ -21,7 +21,7 @@ from cognite.neat._client.data_classes.data_modeling import (
 )
 from cognite.neat._client.data_classes.schema import DMSSchema
 from cognite.neat._constants import COGNITE_SPACES
-from cognite.neat._issues.errors import NeatTypeError, ResourceNotFoundError
+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,
@@ -140,13 +140,20 @@ class _DMSExporter:
                 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
 
@@ -157,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]],
@@ -373,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

@@ -6,7 +6,6 @@ import pandas as pd
 from cognite.client import data_modeling as dm
 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
@@ -30,6 +29,7 @@ from cognite.neat._rules.models._types import (
     ContainerEntityType,
     DmsPropertyType,
     StrListType,
+    URIRefType,
     ViewEntityType,
 )
 from cognite.neat._rules.models.data_types import DataType
@@ -54,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(
@@ -108,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",
@@ -246,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",

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]:

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

@@ -1,5 +1,6 @@
 import warnings
 from collections import Counter, defaultdict
+from functools import lru_cache
 from typing import ClassVar
 
 from cognite.client import data_modeling as dm
@@ -108,15 +109,15 @@ class DMSValidation:
         dms_schema = self._rules.as_schema()
         ref_view_by_id = {view.as_id(): view for view in referenced_views}
         ref_container_by_id = {container.as_id(): container for container in referenced_containers}
+        # All containers and views are the Containers/Views in the DMSRules + the referenced ones
         all_containers_by_id: dict[dm.ContainerId, dm.ContainerApply | dm.Container] = {
             **dict(dms_schema.containers.items()),
             **ref_container_by_id,
         }
         all_views_by_id: dict[dm.ViewId, dm.ViewApply | dm.View] = {**dict(dms_schema.views.items()), **ref_view_by_id}
         properties_by_ids = self._as_properties_by_ids(dms_schema, ref_view_by_id)
-        view_properties_by_id: dict[dm.ViewId, list[tuple[str, ViewProperty | ViewPropertyApply]]] = defaultdict(list)
-        for (view_id, prop_id), prop in properties_by_ids.items():
-            view_properties_by_id[view_id].append((prop_id, prop))
+        view_properties_by_id = self._as_view_properties_by_id(properties_by_ids)
+        parents_view_ids_by_child_id = self._parent_view_ids_by_child_id(all_views_by_id)
 
         issue_list = IssueList()
         # Neat DMS classes Validation
@@ -130,7 +131,9 @@ class DMSValidation:
 
         # SDK classes validation
         issue_list.extend(self._containers_are_proper_size(dms_schema))
-        issue_list.extend(self._validate_reverse_connections(properties_by_ids, all_containers_by_id))
+        issue_list.extend(
+            self._validate_reverse_connections(properties_by_ids, all_containers_by_id, parents_view_ids_by_child_id)
+        )
         issue_list.extend(self._validate_schema(dms_schema, all_views_by_id, all_containers_by_id))
         issue_list.extend(self._validate_referenced_container_limits(dms_schema.views, view_properties_by_id))
         return issue_list
@@ -171,6 +174,32 @@ class DMSValidation:
 
         return properties_by_id
 
+    @staticmethod
+    def _as_view_properties_by_id(
+        properties_by_ids: dict[tuple[ViewId, str], ViewPropertyApply | ViewProperty],
+    ) -> dict[ViewId, list[tuple[str, ViewProperty | ViewPropertyApply]]]:
+        view_properties_by_id: dict[dm.ViewId, list[tuple[str, ViewProperty | ViewPropertyApply]]] = defaultdict(list)
+        for (view_id, prop_id), prop in properties_by_ids.items():
+            view_properties_by_id[view_id].append((prop_id, prop))
+        return view_properties_by_id
+
+    @staticmethod
+    def _parent_view_ids_by_child_id(
+        all_views_by_id: dict[dm.ViewId, dm.ViewApply | dm.View],
+    ) -> dict[ViewId, set[ViewId]]:
+        @lru_cache
+        def get_parents(child_view_id: ViewId) -> set[ViewId]:
+            child_view = all_views_by_id[child_view_id]
+            parents = set(child_view.implements or [])
+            for parent_id in child_view.implements or []:
+                parents.update(get_parents(parent_id))
+            return parents
+
+        parents_by_view: dict[dm.ViewId, set[dm.ViewId]] = {}
+        for view_id in all_views_by_id:
+            parents_by_view[view_id] = get_parents(view_id)
+        return parents_by_view
+
     def _consistent_container_properties(self) -> IssueList:
         container_properties_by_id: dict[tuple[ContainerEntity, str], list[tuple[int, DMSProperty]]] = defaultdict(list)
         for prop_no, prop in enumerate(self._properties):
@@ -374,19 +403,20 @@ class DMSValidation:
 
     def _validate_reverse_connections(
         self,
-        properties_by_ids: dict[tuple[dm.ViewId, str], ViewPropertyApply | ViewProperty],
+        view_property_by_property_id: dict[tuple[dm.ViewId, str], ViewPropertyApply | ViewProperty],
         containers_by_id: dict[dm.ContainerId, dm.ContainerApply | dm.Container],
+        parents_by_view: dict[dm.ViewId, set[dm.ViewId]],
     ) -> IssueList:
         issue_list = IssueList()
         # do not check for reverse connections in Cognite models
         if self._metadata.as_data_model_id() in COGNITE_MODELS:
             return issue_list
 
-        for (view_id, prop_id), prop_ in properties_by_ids.items():
+        for (view_id, prop_id), prop_ in view_property_by_property_id.items():
             if not isinstance(prop_, ReverseDirectRelationApply | ReverseDirectRelation):
                 continue
-            source_id = prop_.through.source, prop_.through.property
-            if source_id not in properties_by_ids:
+            target_id = prop_.through.source, prop_.through.property
+            if target_id not in view_property_by_property_id:
                 issue_list.append(
                     ReversedConnectionNotFeasibleError(
                         view_id,
@@ -396,11 +426,11 @@ class DMSValidation:
                     )
                 )
                 continue
-            if isinstance(source_id[0], dm.ContainerId):
+            if isinstance(target_id[0], dm.ContainerId):
                 # Todo: How to handle this case? Should not happen if you created the model with Neat
                 continue
 
-            target_property = properties_by_ids[(source_id[0], source_id[1])]
+            target_property = view_property_by_property_id[(target_id[0], target_id[1])]
             # Validate that the target is a direct relation pointing to the view_id
             is_direct_relation = False
             if isinstance(target_property, dm.MappedProperty) and isinstance(target_property.type, dm.DirectRelation):
@@ -423,7 +453,8 @@ class DMSValidation:
                 continue
             if not (
                 isinstance(target_property, dm.MappedPropertyApply | dm.MappedProperty)
-                and target_property.source == view_id
+                # The direct relation is pointing to the view_id or one of its parents
+                and (target_property.source == view_id or target_property.source in parents_by_view[view_id])
             ):
                 issue_list.append(
                     ReversedConnectionNotFeasibleError(

cognite/neat/_rules/models/entities/_multi_value.py

@@ -78,3 +78,6 @@ class MultiValueTypeInfo(BaseModel):
     def is_mixed_type(self) -> bool:
         """Will signalize to DMS converter to fall back to string"""
         return not self.is_multi_object_type() and not self.is_multi_data_type()
+
+    def __hash__(self) -> int:
+        return hash(str(self))

cognite/neat/_rules/models/information/_rules.py

@@ -27,7 +27,10 @@ from cognite.neat._rules.models._types import (
     ClassEntityType,
     InformationPropertyType,
     MultiValueTypeType,
+    URIRefType,
 )
+
+# NeatIdType,
 from cognite.neat._rules.models.data_types import DataType
 from cognite.neat._rules.models.entities import (
     ClassEntity,
@@ -45,8 +48,8 @@ class InformationMetadata(BaseMetadata):
     aspect: ClassVar[DataModelAspect] = DataModelAspect.logical
 
     # Linking to Conceptual and Physical data model aspects
-    physical: URIRef | None = Field(None, description="Link to the logical data model aspect")
-    conceptual: URIRef | None = Field(None, description="Link to the logical data model aspect")
+    physical: URIRef | str | None = Field(None, description="Link to the physical data model aspect")
+    conceptual: URIRef | str | None = Field(None, description="Link to the conceptual data model aspect")
 
 
 def _get_metadata(context: Any) -> InformationMetadata | None:
@@ -70,6 +73,12 @@ class InformationClass(SheetRow):
     description: str | None = Field(alias="Description", default=None)
     implements: ClassEntityList | None = Field(alias="Implements", default=None)
 
+    physical: URIRefType | None = Field(
+        None,
+        description="Link to the class representation in the physical data model aspect",
+    )
+    conceptual: URIRefType | None = Field(None, description="Link to the conceptual data model aspect")
+
     def _identifier(self) -> tuple[Hashable, ...]:
         return (self.class_,)
 
@@ -128,6 +137,12 @@ class InformationProperty(SheetRow):
         description="Flag to indicate if the property is inherited, only use for internal purposes",
     )
 
+    physical: URIRefType | None = Field(
+        None,
+        description="Link to the class representation in the physical data model aspect",
+    )
+    conceptual: URIRefType | None = Field(None, description="Link to the conceptual data model aspect")
+
     def _identifier(self) -> tuple[Hashable, ...]:
         return self.class_, self.property_