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

cognite/neat/_client/data_classes/data_modeling.py

@@ -2,6 +2,8 @@ from abc import ABC, abstractmethod
 from collections.abc import Hashable, ItemsView, Iterable, Iterator, KeysView, Mapping, MutableMapping, ValuesView
 from typing import (
     Any,
+    Literal,
+    TypeAlias,
     TypeVar,
     cast,
     final,
@@ -24,6 +26,8 @@ from cognite.client.data_classes.data_modeling import (
 from cognite.client.utils._auxiliary import load_yaml_or_json
 from cognite.client.utils._pandas_helpers import convert_nullable_int_cols
 
+Component: TypeAlias = Literal["spaces", "data_models", "views", "containers", "node_types"]
+
 T_ID = TypeVar("T_ID", bound=Hashable)
 
 

cognite/neat/_graph/extractors/_base.py

@@ -10,6 +10,13 @@ class BaseExtractor:
     extractors must implement.
     """
 
+    def _get_activity_names(self) -> list[str]:
+        """Returns the name of the activities that the extractor performs,
+        i.e., the actions that it performs when you call extract().."""
+        # This method can be overridden by subclasses that runs multiple extractors
+        # for example the ClassicGraphExtractor
+        return [type(self).__name__]
+
     @abstractmethod
     def extract(self) -> Iterable[Triple]:
         raise NotImplementedError()

cognite/neat/_graph/extractors/_classic_cdf/_classic.py

@@ -11,7 +11,7 @@ from cognite.neat._constants import CLASSIC_CDF_NAMESPACE
 from cognite.neat._graph.extractors._base import BaseExtractor
 from cognite.neat._issues.warnings import CDFAuthWarning
 from cognite.neat._shared import Triple
-from cognite.neat._utils.collection_ import chunker
+from cognite.neat._utils.collection_ import chunker, iterate_progress_bar
 from cognite.neat._utils.rdf_ import remove_namespace_from_uri
 
 from ._assets import AssetsExtractor
@@ -92,6 +92,7 @@ class ClassicGraphExtractor(BaseExtractor):
         data_set_external_id: str | None = None,
         root_asset_external_id: str | None = None,
         namespace: Namespace | None = None,
+        limit_per_type: int | None = None,
     ):
         self._client = client
         if sum([bool(data_set_external_id), bool(root_asset_external_id)]) != 1:
@@ -99,12 +100,27 @@ class ClassicGraphExtractor(BaseExtractor):
         self._root_asset_external_id = root_asset_external_id
         self._data_set_external_id = data_set_external_id
         self._namespace = namespace or CLASSIC_CDF_NAMESPACE
-        self._extractor_args = dict(namespace=self._namespace, unpack_metadata=False, as_write=True, camel_case=True)
+        self._extractor_args = dict(
+            namespace=self._namespace, unpack_metadata=False, as_write=True, camel_case=True, limit=limit_per_type
+        )
+        self._limit_per_type = limit_per_type
 
         self._source_external_ids_by_type: dict[InstanceIdPrefix, set[str]] = defaultdict(set)
         self._target_external_ids_by_type: dict[InstanceIdPrefix, set[str]] = defaultdict(set)
         self._labels: set[str] = set()
         self._data_set_ids: set[int] = set()
+        self._extracted_labels = False
+        self._extracted_data_sets = False
+
+    def _get_activity_names(self) -> list[str]:
+        activities = [data_access_object.extractor_cls.__name__ for data_access_object in self._classic_node_types] + [
+            RelationshipsExtractor.__name__,
+        ]
+        if self._extracted_labels:
+            activities.append(LabelsExtractor.__name__)
+        if self._extracted_data_sets:
+            activities.append(DataSetExtractor.__name__)
+        return activities
 
     def extract(self) -> Iterable[Triple]:
         """Extracts all classic CDF Resources."""
@@ -118,11 +134,15 @@ class ClassicGraphExtractor(BaseExtractor):
             yield from self._extract_labels()
         except CogniteAPIError as e:
             warnings.warn(CDFAuthWarning("extract labels", str(e)), stacklevel=2)
+        else:
+            self._extracted_labels = True
 
         try:
             yield from self._extract_data_sets()
         except CogniteAPIError as e:
             warnings.warn(CDFAuthWarning("extract data sets", str(e)), stacklevel=2)
+        else:
+            self._extracted_data_sets = True
 
     def _extract_core_start_nodes(self):
         for core_node in self._classic_node_types:
@@ -206,14 +226,4 @@ class ClassicGraphExtractor(BaseExtractor):
     @staticmethod
     def _chunk(items: Sequence, description: str) -> Iterable:
         to_iterate: Iterable = chunker(items, chunk_size=1000)
-        try:
-            from rich.progress import track
-        except ModuleNotFoundError:
-            ...
-        else:
-            to_iterate = track(
-                to_iterate,
-                total=(len(items) // 1_000) + 1,
-                description=description,
-            )
-        return to_iterate
+        return iterate_progress_bar(to_iterate, (len(items) // 1_000) + 1, description)

cognite/neat/_graph/loaders/_rdf2dms.py

@@ -14,7 +14,7 @@ from cognite.client.data_classes.data_modeling.ids import InstanceId
 from cognite.client.data_classes.data_modeling.views import SingleEdgeConnection
 from cognite.client.exceptions import CogniteAPIError
 from pydantic import BaseModel, ValidationInfo, create_model, field_validator
-from rdflib import RDF
+from rdflib import RDF, URIRef
 
 from cognite.neat._graph._tracking import LogTracker, Tracker
 from cognite.neat._issues import IssueList, NeatIssue, NeatIssueList
@@ -25,8 +25,10 @@ from cognite.neat._issues.errors import (
     ResourceRetrievalError,
 )
 from cognite.neat._issues.warnings import PropertyTypeNotSupportedWarning
+from cognite.neat._rules.analysis._dms import DMSAnalysis
 from cognite.neat._rules.models import DMSRules
 from cognite.neat._rules.models.data_types import _DATA_TYPE_BY_DMS_TYPE, Json
+from cognite.neat._rules.models.entities._single_value import ViewEntity
 from cognite.neat._shared import InstanceType
 from cognite.neat._store import NeatGraphStore
 from cognite.neat._utils.auxiliary import create_sha256_hash
@@ -52,16 +54,18 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         graph_store: NeatGraphStore,
         data_model: dm.DataModel[dm.View] | None,
         instance_space: str,
-        class_by_view_id: dict[ViewId, str] | None = None,
+        class_neat_id_by_view_id: dict[ViewId, URIRef] | None = None,
         create_issues: Sequence[NeatIssue] | None = None,
         tracker: type[Tracker] | None = None,
+        rules: DMSRules | None = None,
     ):
         super().__init__(graph_store)
         self.data_model = data_model
         self.instance_space = instance_space
-        self.class_by_view_id = class_by_view_id or {}
+        self.class_neat_id_by_view_id = class_neat_id_by_view_id or {}
         self._issues = IssueList(create_issues or [])
         self._tracker: type[Tracker] = tracker or LogTracker
+        self.rules = rules
 
     @classmethod
     def from_data_model_id(
@@ -95,7 +99,17 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
                     reason=str(e),
                 )
             )
-        return cls(graph_store, data_model, instance_space, {}, issues)
+
+        class_neat_id_by_view_id = {view.view.as_id(): view.logical for view in rules.views if view.logical}
+
+        return cls(
+            graph_store,
+            data_model,
+            instance_space,
+            class_neat_id_by_view_id,
+            issues,
+            rules=rules,
+        )
 
     def _load(self, stop_on_exception: bool = False) -> Iterable[dm.InstanceApply | NeatIssue]:
         if self._issues.has_errors and stop_on_exception:
@@ -106,6 +120,13 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         if not self.data_model:
             # There should already be an error in this case.
             return
+
+        views_with_linked_properties = (
+            DMSAnalysis(self.rules).views_with_properties_linked_to_classes(consider_inheritance=True)
+            if self.rules and self.rules.metadata.logical
+            else None
+        )
+
         view_ids = [repr(v.as_id()) for v in self.data_model.views]
         tracker = self._tracker(type(self).__name__, view_ids, "views")
         for view in self.data_model.views:
@@ -114,17 +135,35 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             pydantic_cls, edge_by_type, issues = self._create_validation_classes(view)  # type: ignore[var-annotated]
             yield from issues
             tracker.issue(issues)
-            class_name = self.class_by_view_id.get(view.as_id(), view.external_id)
 
-            for identifier, properties in self.graph_store.read(class_name):
+            # this assumes no changes in the suffix of view and class
+
+            if views_with_linked_properties:
+                # we need graceful exit if the view is not in the view_property_pairs
+                property_link_pairs = views_with_linked_properties.get(ViewEntity.from_id(view_id))
+
+                if class_neat_id := self.class_neat_id_by_view_id.get(view_id):
+                    reader = self.graph_store._read_via_rules_linkage(class_neat_id, property_link_pairs)
+                else:
+                    error_view = ResourceRetrievalError(view_id, "view", "View not linked to class")
+                    tracker.issue(error_view)
+                    if stop_on_exception:
+                        raise error_view
+                    yield error_view
+
+            else:
+                reader = self.graph_store.read(view.external_id)
+
+            for identifier, properties in reader:
                 try:
+                    print(view_id)
                     yield self._create_node(identifier, properties, pydantic_cls, view_id)
                 except ValueError as e:
-                    error = ResourceCreationError(identifier, "node", error=str(e))
-                    tracker.issue(error)
+                    error_node = ResourceCreationError(identifier, "node", error=str(e))
+                    tracker.issue(error_node)
                     if stop_on_exception:
-                        raise error from e
-                    yield error
+                        raise error_node from e
+                    yield error_node
                 yield from self._create_edges(identifier, properties, edge_by_type, tracker)
             tracker.finish(repr(view_id))
 
@@ -244,7 +283,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         return dm.NodeApply(
             space=self.instance_space,
             external_id=identifier,
-            type=dm.DirectRelationReference(view_id.space, type_) if type_ is not None else None,
+            type=(dm.DirectRelationReference(view_id.space, view_id.external_id) if type_ is not None else None),
             sources=[dm.NodeOrEdgeData(source=view_id, properties=dict(created.model_dump().items()))],
         )
 

cognite/neat/_graph/transformers/__init__.py

@@ -5,7 +5,7 @@ from ._classic_cdf import (
     AssetRelationshipConnector,
     AssetSequenceConnector,
     AssetTimeSeriesConnector,
-    RelationshipToSchemaTransformer,
+    RelationshipAsEdgeTransformer,
 )
 from ._rdfpath import AddSelfReferenceProperty, MakeConnectionOnExactMatch
 from ._value_type import SplitMultiValueProperty
@@ -19,7 +19,7 @@ __all__ = [
     "AssetRelationshipConnector",
     "AddSelfReferenceProperty",
     "SplitMultiValueProperty",
-    "RelationshipToSchemaTransformer",
+    "RelationshipAsEdgeTransformer",
     "MakeConnectionOnExactMatch",
 ]
 
@@ -32,6 +32,6 @@ Transformers = (
     | AssetRelationshipConnector
     | AddSelfReferenceProperty
     | SplitMultiValueProperty
-    | RelationshipToSchemaTransformer
+    | RelationshipAsEdgeTransformer
     | MakeConnectionOnExactMatch
 )

cognite/neat/_graph/transformers/_classic_cdf.py

@@ -1,15 +1,22 @@
 import textwrap
 import warnings
 from abc import ABC
+from collections.abc import Callable, Iterable
+from functools import lru_cache
 from typing import cast
 
 from rdflib import RDF, Graph, Literal, Namespace, URIRef
-from rdflib.query import ResultRow
 
 from cognite.neat._constants import CLASSIC_CDF_NAMESPACE, DEFAULT_NAMESPACE
 from cognite.neat._graph import extractors
 from cognite.neat._issues.warnings import ResourceNotFoundWarning
-from cognite.neat._utils.rdf_ import Triple, add_triples_in_batch, remove_namespace_from_uri
+from cognite.neat._utils.collection_ import iterate_progress_bar
+from cognite.neat._utils.rdf_ import (
+    Triple,
+    add_triples_in_batch,
+    remove_instance_ids_in_batch,
+    remove_namespace_from_uri,
+)
 
 from ._base import BaseTransformer
 
@@ -235,31 +242,40 @@ class AssetRelationshipConnector(BaseTransformer):
                     graph.remove((relationship_id, self.relationship_target_xid_prop, None))
 
 
-class RelationshipToSchemaTransformer(BaseTransformer):
-    """Replaces relationships with a schema.
+class RelationshipAsEdgeTransformer(BaseTransformer):
+    """Converts relationships into edges in the graph.
 
-    This transformer analyzes the relationships in the graph and modifies them to be part of the schema
-    for Assets, Events, Files, Sequences, and TimeSeries. Relationships without any properties
-    are replaced by a simple relationship between the source and target nodes. Relationships with
-    properties are replaced by a schema that contains the properties as attributes.
+    This transformer converts relationships into edges in the graph. This is useful as the
+    edges will be picked up as part of the schema connected to Assets, Events, Files, Sequenses,
+    and TimeSeries in the InferenceImporter.
 
     Args:
-        limit: The minimum number of relationships that need to be present for it
-            to be converted into a schema. Default is 1.
+        min_relationship_types: The minimum number of relationship types that must exists to convert those
+            relationships to edges. For example, if there is only 5 relationships between Assets and TimeSeries,
+            and limit is 10, those relationships will not be converted to edges.
+        limit_per_type: The number of conversions to perform per relationship type. For example, if there are 10
+            relationships between Assets and TimeSeries, and limit_per_type is 1, only 1 of those relationships
+            will be converted to an edge. If None, all relationships will be converted.
 
     """
 
-    def __init__(self, limit: int = 1, namespace: Namespace = CLASSIC_CDF_NAMESPACE) -> None:
-        self._limit = limit
+    def __init__(
+        self,
+        min_relationship_types: int = 1,
+        limit_per_type: int | None = None,
+        namespace: Namespace = CLASSIC_CDF_NAMESPACE,
+    ) -> None:
+        self._min_relationship_types = min_relationship_types
+        self._limit_per_type = limit_per_type
         self._namespace = namespace
 
     _NOT_PROPERTIES: frozenset[str] = frozenset(
         {"sourceExternalId", "targetExternalId", "externalId", "sourceType", "targetType"}
     )
     _RELATIONSHIP_NODE_TYPES: tuple[str, ...] = tuple(["Asset", "Event", "File", "Sequence", "TimeSeries"])
-    description = "Replaces relationships with a schema"
+    description = "Converts relationships to edge"
     _use_only_once: bool = True
-    _need_changes = frozenset({str(extractors.RelationshipsExtractor.__name__)})
+    _need_changes = frozenset({extractors.RelationshipsExtractor.__name__})
 
     _count_by_source_target = """PREFIX classic: <{namespace}>
 
@@ -286,47 +302,99 @@ WHERE {{
     ?entity classic:externalId "{external_id}" .
 }}"""
 
+    @staticmethod
+    def create_lookup_entity_with_external_id(graph: Graph, namespace: Namespace) -> Callable[[str, str], URIRef]:
+        @lru_cache(maxsize=10_000)
+        def lookup_entity_with_external_id(entity_type: str, external_id: str) -> URIRef:
+            query = RelationshipAsEdgeTransformer._lookup_entity_query.format(
+                namespace=namespace, entity_type=entity_type, external_id=external_id
+            )
+            result = list(graph.query(query))
+            if len(result) == 1:
+                return cast(URIRef, result[0][0])  # type: ignore[index]
+            raise ValueError(f"Could not find entity with external_id {external_id} and type {entity_type}")
+
+        return lookup_entity_with_external_id
+
     def transform(self, graph: Graph) -> None:
+        lookup_entity_with_external_id = self.create_lookup_entity_with_external_id(graph, self._namespace)
         for source_type in self._RELATIONSHIP_NODE_TYPES:
             for target_type in self._RELATIONSHIP_NODE_TYPES:
                 query = self._count_by_source_target.format(
                     namespace=self._namespace, source_type=source_type, target_type=target_type
                 )
-                for instance_count in graph.query(query):
-                    if int(instance_count[0]) < self._limit:  # type: ignore[index, arg-type]
+                for instance_count_res in graph.query(query):
+                    instance_count = int(instance_count_res[0])  # type: ignore[index, arg-type]
+                    if instance_count < self._min_relationship_types:
                         continue
-                    query = self._instances.format(
-                        namespace=self._namespace, source_type=source_type, target_type=target_type
+                    edge_triples = self._edge_triples(
+                        graph, source_type, target_type, instance_count, lookup_entity_with_external_id
                     )
-                    for result in graph.query(query):
-                        instance_id = cast(URIRef, result[0])  # type: ignore[index, misc]
-                        self._convert_relationship_to_schema(graph, instance_id, source_type, target_type)
+                    add_triples_in_batch(graph, edge_triples)
 
-    def _convert_relationship_to_schema(
-        self, graph: Graph, instance_id: URIRef, source_type: str, target_type: str
-    ) -> None:
-        result = cast(list[ResultRow], list(graph.query(f"DESCRIBE <{instance_id}>")))
+    def _edge_triples(
+        self,
+        graph: Graph,
+        source_type: str,
+        target_type: str,
+        instance_count: int,
+        lookup_entity_with_external_id: Callable[[str, str], URIRef],
+    ) -> Iterable[Triple]:
+        query = self._instances.format(namespace=self._namespace, source_type=source_type, target_type=target_type)
+        total_instance_count = instance_count if self._limit_per_type is None else self._limit_per_type
+
+        converted_relationships: list[URIRef] = []
+        for no, result in enumerate(
+            iterate_progress_bar(graph.query(query), total=total_instance_count, description="Relationships to edges")
+        ):
+            if self._limit_per_type is not None and no >= self._limit_per_type:
+                break
+            relationship_id = cast(URIRef, result[0])  # type: ignore[index, misc]
+            yield from self._relationship_as_edge(
+                graph, relationship_id, source_type, target_type, lookup_entity_with_external_id
+            )
+            converted_relationships.append(relationship_id)
+
+            if len(converted_relationships) >= 1_000:
+                remove_instance_ids_in_batch(graph, converted_relationships)
+                converted_relationships = []
+
+        remove_instance_ids_in_batch(graph, converted_relationships)
+
+    def _relationship_as_edge(
+        self,
+        graph: Graph,
+        relationship_id: URIRef,
+        source_type: str,
+        target_type: str,
+        lookup_entity_with_external_id: Callable[[str, str], URIRef],
+    ) -> list[Triple]:
+        relationship_triples = cast(list[Triple], list(graph.query(f"DESCRIBE <{relationship_id}>")))
         object_by_predicates = cast(
-            dict[str, URIRef | Literal], {remove_namespace_from_uri(row[1]): row[2] for row in result}
+            dict[str, URIRef | Literal], {remove_namespace_from_uri(row[1]): row[2] for row in relationship_triples}
         )
         source_external_id = cast(URIRef, object_by_predicates["sourceExternalId"])
         target_source_id = cast(URIRef, object_by_predicates["targetExternalId"])
         try:
-            source_id = self._lookup_entity(graph, source_type, source_external_id)
+            source_id = lookup_entity_with_external_id(source_type, source_external_id)
         except ValueError:
-            warnings.warn(ResourceNotFoundWarning(source_external_id, "class", str(instance_id), "class"), stacklevel=2)
-            return None
+            warnings.warn(
+                ResourceNotFoundWarning(source_external_id, "class", str(relationship_id), "class"), stacklevel=2
+            )
+            return []
         try:
-            target_id = self._lookup_entity(graph, target_type, target_source_id)
+            target_id = lookup_entity_with_external_id(target_type, target_source_id)
         except ValueError:
-            warnings.warn(ResourceNotFoundWarning(target_source_id, "class", str(instance_id), "class"), stacklevel=2)
-            return None
-        external_id = str(object_by_predicates["externalId"])
+            warnings.warn(
+                ResourceNotFoundWarning(target_source_id, "class", str(relationship_id), "class"), stacklevel=2
+            )
+            return []
+        edge_id = str(object_by_predicates["externalId"])
         # If there is properties on the relationship, we create a new intermediate node
-        self._create_node(graph, object_by_predicates, external_id, source_id, target_id, self._predicate(target_type))
-
-        for triple in result:
-            graph.remove(triple)  # type: ignore[arg-type]
+        edge_type = self._namespace[f"{source_type}To{target_type}Edge"]
+        return self._create_edge(
+            object_by_predicates, edge_id, source_id, target_id, self._predicate(target_type), edge_type
+        )
 
     def _lookup_entity(self, graph: Graph, entity_type: str, external_id: str) -> URIRef:
         query = self._lookup_entity_query.format(
@@ -337,38 +405,38 @@ WHERE {{
             return cast(URIRef, result[0][0])  # type: ignore[index]
         raise ValueError(f"Could not find entity with external_id {external_id} and type {entity_type}")
 
-    def _create_node(
+    def _create_edge(
         self,
-        graph: Graph,
         objects_by_predicates: dict[str, URIRef | Literal],
         external_id: str,
         source_id: URIRef,
         target_id: URIRef,
         predicate: URIRef,
-    ) -> None:
+        edge_type: URIRef,
+    ) -> list[Triple]:
         """Creates a new intermediate node for the relationship with properties."""
         # Create the entity with the properties
-        instance_id = self._namespace[external_id]
-        graph.add((instance_id, RDF.type, self._namespace["Edge"]))
+        edge_triples: list[Triple] = []
+        edge_id = self._namespace[external_id]
+
+        edge_triples.append((edge_id, RDF.type, edge_type))
         for prop_name, object_ in objects_by_predicates.items():
             if prop_name in self._NOT_PROPERTIES:
                 continue
-            graph.add((instance_id, self._namespace[prop_name], object_))
+            edge_triples.append((edge_id, self._namespace[prop_name], object_))
 
         # Target and Source IDs will always be a combination of Asset, Sequence, Event, TimeSeries, and File.
         # If we assume source ID is an asset and target ID is a time series, then
         # before we had relationship pointing to both: timeseries <- relationship -> asset
-        # After, we want asset -> timeseries, and asset.edgeSource -> Edge
+        # After, we want asset <-> Edge -> TimeSeries
         # and the new edge will point to the asset and the timeseries through startNode and endNode
 
-        # Link the two entities directly,
-        graph.add((source_id, predicate, target_id))
-        # Create the new edge
-        graph.add((instance_id, self._namespace["startNode"], source_id))
-        graph.add((instance_id, self._namespace["endNode"], target_id))
-
-        # Link the source to the edge properties
-        graph.add((source_id, self._namespace["edgeSource"], instance_id))
+        # Link the source to the new edge
+        edge_triples.append((source_id, predicate, edge_id))
+        # Link the edge to the source and target
+        edge_triples.append((edge_id, self._namespace["startNode"], source_id))
+        edge_triples.append((edge_id, self._namespace["endNode"], target_id))
+        return edge_triples
 
     def _predicate(self, target_type: str) -> URIRef:
         return self._namespace[f"relationship{target_type.capitalize()}"]

cognite/neat/_issues/warnings/__init__.py

@@ -36,6 +36,7 @@ from ._properties import (
 from ._resources import (
     ResourceNeatWarning,
     ResourceNotFoundWarning,
+    ResourceRegexViolationWarning,
     ResourceRetrievalWarning,
     ResourcesDuplicatedWarning,
     ResourceTypeNotSupportedWarning,
@@ -64,6 +65,7 @@ __all__ = [
     "ResourceNotFoundWarning",
     "ResourceTypeNotSupportedWarning",
     "ResourceRetrievalWarning",
+    "ResourceRegexViolationWarning",
     "PrincipleOneModelOneSpaceWarning",
     "PrincipleMatchingSpaceAndVersionWarning",
     "PrincipleSolutionBuildsOnEnterpriseWarning",

cognite/neat/_issues/warnings/_resources.py

@@ -13,6 +13,21 @@ class ResourceNeatWarning(NeatWarning, Generic[T_Identifier]):
     resource_type: ResourceType
 
 
+@dataclass(unsafe_hash=True)
+class ResourceRegexViolationWarning(ResourceNeatWarning):
+    """The {resource_type} with identifier {identifier} in the {location} is violating
+    the CDF regex {regex}. This will lead to errors when converting to DMS data model.
+    """
+
+    fix = (
+        "Either export the data model and make the necessary changes manually"
+        " or run prepare.cdf_compliant_external_ids."
+    )
+
+    location: str
+    regex: str
+
+
 @dataclass(unsafe_hash=True)
 class ResourceNotFoundWarning(ResourceNeatWarning, Generic[T_Identifier, T_ReferenceIdentifier]):
     """The {resource_type} with identifier {identifier} referred by {referred_type} {referred_by} does not exist.

cognite/neat/_rules/analysis/_base.py

@@ -4,23 +4,25 @@ from abc import ABC, abstractmethod
 from collections import defaultdict
 from collections.abc import Set
 from dataclasses import dataclass
-from typing import Generic, TypeVar
+from typing import Generic, TypeVar, cast
 
 import pandas as pd
-from pydantic import BaseModel
+from rdflib import URIRef
 
 from cognite.neat._rules.models._base_rules import BaseRules
 from cognite.neat._rules.models._rdfpath import RDFPath
+from cognite.neat._rules.models.dms._rules import DMSProperty, DMSView
 from cognite.neat._rules.models.entities import (
     ClassEntity,
     Entity,
 )
 from cognite.neat._rules.models.information import InformationProperty
+from cognite.neat._rules.models.information._rules import InformationClass
 from cognite.neat._utils.rdf_ import get_inheritance_path
 
 T_Rules = TypeVar("T_Rules", bound=BaseRules)
-T_Property = TypeVar("T_Property", bound=BaseModel)
-T_Class = TypeVar("T_Class", bound=BaseModel)
+T_Property = TypeVar("T_Property", bound=InformationProperty | DMSProperty)
+T_Class = TypeVar("T_Class", bound=InformationClass | DMSView)
 T_ClassEntity = TypeVar("T_ClassEntity", bound=Entity)
 T_PropertyEntity = TypeVar("T_PropertyEntity", bound=Entity | str)
 
@@ -108,6 +110,14 @@ class BaseAnalysis(ABC, Generic[T_Rules, T_Class, T_Property, T_ClassEntity, T_P
     def inherited_referred_classes(self) -> set[ClassEntity]:
         raise NotImplementedError
 
+    @property
+    def properties_by_neat_id(self) -> dict[URIRef, T_Property]:
+        return {cast(URIRef, prop.neatId): prop for prop in self._get_properties()}
+
+    @property
+    def classes_by_neat_id(self) -> dict[URIRef, T_Class]:
+        return {cast(URIRef, class_.neatId): class_ for class_ in self._get_classes()}
+
     # Todo Lru cache this method.
     def class_parent_pairs(self, allow_different_space: bool = False) -> dict[T_ClassEntity, list[T_ClassEntity]]:
         """This only returns class - parent pairs only if parent is in the same data model"""
@@ -176,7 +186,7 @@ class BaseAnalysis(ABC, Generic[T_Rules, T_Class, T_Property, T_ClassEntity, T_P
             # ParentClassEntity -> ClassEntity to match the type of class_property_pairs
             if parent in class_property_pairs:
                 for property_ in class_property_pairs[parent]:
-                    property_ = property_.model_copy()
+                    property_ = property_.model_copy()  # type: ignore
 
                     # This corresponds to importing properties from parent class
                     # making sure that the property is attached to desired child class

cognite/neat/_rules/analysis/_dms.py

@@ -1,3 +1,7 @@
+from collections import defaultdict
+
+from rdflib import URIRef
+
 from cognite.neat._constants import DMS_LISTABLE_PROPERTY_LIMIT
 from cognite.neat._rules.models.dms import DMSProperty, DMSRules, DMSView
 from cognite.neat._rules.models.entities import ViewEntity
@@ -35,3 +39,19 @@ class DMSAnalysis(BaseAnalysis[DMSRules, DMSView, DMSProperty, ViewEntity, str])
 
     def _get_prop_entity(self, property_: DMSProperty) -> str:
         return property_.view_property
+
+    def views_with_properties_linked_to_classes(
+        self,
+        consider_inheritance: bool = False,
+        allow_different_namespace: bool = False,
+    ) -> dict[ViewEntity, dict[str, URIRef]]:
+        view_property_pairs = self.classes_with_properties(consider_inheritance, allow_different_namespace)
+
+        view_and_properties_with_links: dict[ViewEntity, dict[str, URIRef]] = defaultdict(dict)
+
+        for view, properties in view_property_pairs.items():
+            view_and_properties_with_links[view] = {
+                prop.view_property: prop.logical for prop in properties if prop.logical
+            }
+
+        return view_and_properties_with_links