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

cognite/neat/_graph/queries/_base.py

@@ -12,7 +12,7 @@ from cognite.neat._rules._constants import EntityTypes
 from cognite.neat._rules.models.entities import ClassEntity
 from cognite.neat._rules.models.information import InformationRules
 from cognite.neat._shared import InstanceType
-from cognite.neat._utils.rdf_ import remove_namespace_from_uri
+from cognite.neat._utils.rdf_ import remove_instance_ids_in_batch, remove_namespace_from_uri
 
 from ._construct import build_construct_query
 
@@ -342,3 +342,19 @@ class Queries:
             self.graph.query(query.format(unknownType=str(UNKNOWN_TYPE))),
         ):
             yield cast(URIRef, source_type), cast(URIRef, property_), [URIRef(uri) for uri in value_types.split(",")]
+
+    def drop_types(self, type_: list[URIRef]) -> dict[URIRef, int]:
+        """Drop types from the graph store
+
+        Args:
+            type_: List of types to drop
+
+        Returns:
+            Dictionary of dropped types
+        """
+        dropped_types: dict[URIRef, int] = {}
+        for t in type_:
+            instance_ids = self.list_instances_ids_of_class(t)
+            dropped_types[t] = len(instance_ids)
+            remove_instance_ids_in_batch(self.graph, instance_ids)
+        return dropped_types

cognite/neat/_graph/transformers/_classic_cdf.py

@@ -1,4 +1,6 @@
+import textwrap
 import warnings
+from abc import ABC
 from typing import cast
 
 from rdflib import RDF, Graph, Literal, Namespace, URIRef
@@ -7,7 +9,7 @@ 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 remove_namespace_from_uri
+from cognite.neat._utils.rdf_ import Triple, add_triples_in_batch, remove_namespace_from_uri
 
 from ._base import BaseTransformer
 
@@ -32,8 +34,8 @@ class AddAssetDepth(BaseTransformer):
         depth_typing: dict[int, str] | None = None,
     ):
         self.asset_type = asset_type or DEFAULT_NAMESPACE.Asset
-        self.root_prop = root_prop or DEFAULT_NAMESPACE.root
-        self.parent_prop = parent_prop or DEFAULT_NAMESPACE.parent
+        self.root_prop = root_prop or DEFAULT_NAMESPACE.rootId
+        self.parent_prop = parent_prop or DEFAULT_NAMESPACE.parentId
         self.depth_typing = depth_typing
 
     def transform(self, graph: Graph) -> None:
@@ -75,7 +77,33 @@ class AddAssetDepth(BaseTransformer):
             return None
 
 
-class AssetTimeSeriesConnector(BaseTransformer):
+class BaseAssetConnector(BaseTransformer, ABC):
+    _asset_type: URIRef = DEFAULT_NAMESPACE.Asset
+    _item_type: URIRef
+    _default_attribute: URIRef
+    _connection_type: URIRef
+
+    _select_item_ids = "SELECT DISTINCT ?item_id WHERE {{?item_id a <{item_type}>}}"
+    _select_connected_assets: str = textwrap.dedent("""SELECT ?asset_id WHERE {{
+                              <{item_id}> <{attribute}> ?asset_id .
+                              ?asset_id a <{asset_type}>}}""")
+
+    def __init__(self, attribute: URIRef | None = None) -> None:
+        self._attribute = attribute or self._default_attribute
+
+    def transform(self, graph: Graph) -> None:
+        for item_id, *_ in graph.query(self._select_item_ids.format(item_type=self._item_type)):  # type: ignore[misc]
+            triples: list[Triple] = []
+            for asset_id, *_ in graph.query(  # type: ignore[misc]
+                self._select_connected_assets.format(
+                    item_id=item_id, attribute=self._attribute, asset_type=self._asset_type
+                )
+            ):
+                triples.append((asset_id, self._connection_type, item_id))  # type: ignore[arg-type]
+            add_triples_in_batch(graph, triples)
+
+
+class AssetTimeSeriesConnector(BaseAssetConnector):
     description: str = "Connects assets to timeseries, thus forming bi-directional connection"
     _use_only_once: bool = True
     _need_changes = frozenset(
@@ -84,41 +112,12 @@ class AssetTimeSeriesConnector(BaseTransformer):
             str(extractors.TimeSeriesExtractor.__name__),
         }
     )
-    _asset_template: str = """SELECT ?asset_id WHERE {{
-                              <{timeseries_id}> <{asset_prop}> ?asset_id .
-                              ?asset_id a <{asset_type}>}}"""
+    _item_type = DEFAULT_NAMESPACE.TimeSeries
+    _default_attribute = DEFAULT_NAMESPACE.assetId
+    _connection_type = DEFAULT_NAMESPACE.timeSeries
 
-    def __init__(
-        self,
-        asset_type: URIRef | None = None,
-        timeseries_type: URIRef | None = None,
-        asset_prop: URIRef | None = None,
-    ):
-        self.asset_type = asset_type or DEFAULT_NAMESPACE.Asset
-        self.timeseries_type = timeseries_type or DEFAULT_NAMESPACE.TimeSeries
-        self.asset_prop = asset_prop or DEFAULT_NAMESPACE.asset
 
-    def transform(self, graph: Graph) -> None:
-        for ts_id_result in graph.query(
-            f"SELECT DISTINCT ?timeseries_id WHERE {{?timeseries_id a <{self.timeseries_type}>}}"
-        ):
-            timeseries_id: URIRef = cast(tuple, ts_id_result)[0]
-
-            if asset_id_res := list(
-                graph.query(
-                    self._asset_template.format(
-                        timeseries_id=timeseries_id,
-                        asset_prop=self.asset_prop,
-                        asset_type=self.asset_type,
-                    )
-                )
-            ):
-                # timeseries can be connected to only one asset in the graph
-                asset_id = cast(list[tuple], asset_id_res)[0][0]
-                graph.add((asset_id, DEFAULT_NAMESPACE.timeSeries, timeseries_id))
-
-
-class AssetSequenceConnector(BaseTransformer):
+class AssetSequenceConnector(BaseAssetConnector):
     description: str = "Connects assets to sequences, thus forming bi-directional connection"
     _use_only_once: bool = True
     _need_changes = frozenset(
@@ -127,41 +126,12 @@ class AssetSequenceConnector(BaseTransformer):
             str(extractors.SequencesExtractor.__name__),
         }
     )
-    _asset_template: str = """SELECT ?asset_id WHERE {{
-                              <{sequence_id}> <{asset_prop}> ?asset_id .
-                              ?asset_id a <{asset_type}>}}"""
-
-    def __init__(
-        self,
-        asset_type: URIRef | None = None,
-        sequence_type: URIRef | None = None,
-        asset_prop: URIRef | None = None,
-    ):
-        self.asset_type = asset_type or DEFAULT_NAMESPACE.Asset
-        self.sequence_type = sequence_type or DEFAULT_NAMESPACE.Sequence
-        self.asset_prop = asset_prop or DEFAULT_NAMESPACE.asset
-
-    def transform(self, graph: Graph) -> None:
-        for sequency_id_result in graph.query(
-            f"SELECT DISTINCT ?sequence_id WHERE {{?sequence_id a <{self.sequence_type}>}}"
-        ):
-            sequence_id: URIRef = cast(tuple, sequency_id_result)[0]
-
-            if asset_id_res := list(
-                graph.query(
-                    self._asset_template.format(
-                        sequence_id=sequence_id,
-                        asset_prop=self.asset_prop,
-                        asset_type=self.asset_type,
-                    )
-                )
-            ):
-                # sequence can be connected to only one asset in the graph
-                asset_id = cast(list[tuple], asset_id_res)[0][0]
-                graph.add((asset_id, DEFAULT_NAMESPACE.sequence, sequence_id))
+    _item_type = DEFAULT_NAMESPACE.Sequence
+    _default_attribute = DEFAULT_NAMESPACE.assetId
+    _connection_type = DEFAULT_NAMESPACE.sequence
 
 
-class AssetFileConnector(BaseTransformer):
+class AssetFileConnector(BaseAssetConnector):
     description: str = "Connects assets to files, thus forming bi-directional connection"
     _use_only_once: bool = True
     _need_changes = frozenset(
@@ -170,39 +140,12 @@ class AssetFileConnector(BaseTransformer):
             str(extractors.FilesExtractor.__name__),
         }
     )
-    _asset_template: str = """SELECT ?asset_id WHERE {{
-                              <{file_id}> <{asset_prop}> ?asset_id .
-                              ?asset_id a <{asset_type}>}}"""
-
-    def __init__(
-        self,
-        asset_type: URIRef | None = None,
-        file_type: URIRef | None = None,
-        asset_prop: URIRef | None = None,
-    ):
-        self.asset_type = asset_type or DEFAULT_NAMESPACE.Asset
-        self.file_type = file_type or DEFAULT_NAMESPACE.File
-        self.asset_prop = asset_prop or DEFAULT_NAMESPACE.asset
+    _item_type = DEFAULT_NAMESPACE.File
+    _default_attribute = DEFAULT_NAMESPACE.assetIds
+    _connection_type = DEFAULT_NAMESPACE.file
 
-    def transform(self, graph: Graph) -> None:
-        for sequency_id_result in graph.query(f"SELECT DISTINCT ?file_id WHERE {{?file_id a <{self.file_type}>}}"):
-            file_id: URIRef = cast(tuple, sequency_id_result)[0]
-
-            if assets_id_res := list(
-                graph.query(
-                    self._asset_template.format(
-                        file_id=file_id,
-                        asset_prop=self.asset_prop,
-                        asset_type=self.asset_type,
-                    )
-                )
-            ):
-                # files can be connected to multiple assets in the graph
-                for (asset_id,) in cast(list[tuple], assets_id_res):
-                    graph.add((asset_id, DEFAULT_NAMESPACE.file, file_id))
 
-
-class AssetEventConnector(BaseTransformer):
+class AssetEventConnector(BaseAssetConnector):
     description: str = "Connects assets to events, thus forming bi-directional connection"
     _use_only_once: bool = True
     _need_changes = frozenset(
@@ -211,36 +154,9 @@ class AssetEventConnector(BaseTransformer):
             str(extractors.EventsExtractor.__name__),
         }
     )
-    _asset_template: str = """SELECT ?asset_id WHERE {{
-                              <{event_id}> <{asset_prop}> ?asset_id .
-                              ?asset_id a <{asset_type}>}}"""
-
-    def __init__(
-        self,
-        asset_type: URIRef | None = None,
-        event_type: URIRef | None = None,
-        asset_prop: URIRef | None = None,
-    ):
-        self.asset_type = asset_type or DEFAULT_NAMESPACE.Asset
-        self.event_type = event_type or DEFAULT_NAMESPACE.Event
-        self.asset_prop = asset_prop or DEFAULT_NAMESPACE.asset
-
-    def transform(self, graph: Graph) -> None:
-        for event_id_result in graph.query(f"SELECT DISTINCT ?event_id WHERE {{?event_id a <{self.event_type}>}}"):
-            event_id: URIRef = cast(tuple, event_id_result)[0]
-
-            if assets_id_res := list(
-                graph.query(
-                    self._asset_template.format(
-                        event_id=event_id,
-                        asset_prop=self.asset_prop,
-                        asset_type=self.asset_type,
-                    )
-                )
-            ):
-                # files can be connected to multiple assets in the graph
-                for (asset_id,) in cast(list[tuple], assets_id_res):
-                    graph.add((asset_id, DEFAULT_NAMESPACE.event, event_id))
+    _item_type = DEFAULT_NAMESPACE.Event
+    _default_attribute = DEFAULT_NAMESPACE.assetIds
+    _connection_type = DEFAULT_NAMESPACE.event
 
 
 class AssetRelationshipConnector(BaseTransformer):
@@ -271,9 +187,9 @@ class AssetRelationshipConnector(BaseTransformer):
     ):
         self.asset_type = asset_type or DEFAULT_NAMESPACE.Asset
         self.relationship_type = relationship_type or DEFAULT_NAMESPACE.Relationship
-        self.relationship_source_xid_prop = relationship_source_xid_prop or DEFAULT_NAMESPACE.source_external_id
-        self.relationship_target_xid_prop = relationship_target_xid_prop or DEFAULT_NAMESPACE.target_external_id
-        self.asset_xid_property = asset_xid_property or DEFAULT_NAMESPACE.external_id
+        self.relationship_source_xid_prop = relationship_source_xid_prop or DEFAULT_NAMESPACE.sourceExternalId
+        self.relationship_target_xid_prop = relationship_target_xid_prop or DEFAULT_NAMESPACE.targetExternalId
+        self.asset_xid_property = asset_xid_property or DEFAULT_NAMESPACE.externalId
 
     def transform(self, graph: Graph) -> None:
         for relationship_id_result in graph.query(

cognite/neat/_graph/transformers/_prune_graph.py

@@ -123,4 +123,4 @@ class PruneDanglingNodes(BaseTransformer):
             for node in nodes_without_neighbours:
                 # Remove node and its property triples in the graph
                 if isinstance(node, ResultRow):
-                    graph.remove(triple=(node["subject"], None, None))
+                    graph.remove((node["subject"], None, None))

cognite/neat/_graph/transformers/_rdfpath.py

@@ -49,7 +49,7 @@ class AddSelfReferenceProperty(BaseTransformer):
                 )
 
             traversal = SingleProperty.from_string(
-                class_=property_.class_.id,
+                class_=property_.view.id,
                 property_=f"{self.rules.metadata.prefix}:{property_.property_}",
             )
 

cognite/neat/_issues/warnings/__init__.py

@@ -6,6 +6,7 @@ from cognite.neat._issues._base import DefaultWarning, NeatWarning, _get_subclas
 
 from . import user_modeling
 from ._external import (
+    AuthWarning,
     FileItemNotSupportedWarning,
     FileMissingRequiredFieldWarning,
     FileReadWarning,
@@ -26,6 +27,8 @@ from ._models import (
 from ._properties import (
     PropertyDefinitionDuplicatedWarning,
     PropertyNotFoundWarning,
+    PropertyOverwritingWarning,
+    PropertySkippedWarning,
     PropertyTypeNotSupportedWarning,
     PropertyValueTypeUndefinedWarning,
 )
@@ -52,6 +55,8 @@ __all__ = [
     "PropertyTypeNotSupportedWarning",
     "PropertyNotFoundWarning",
     "PropertyValueTypeUndefinedWarning",
+    "PropertyOverwritingWarning",
+    "PropertySkippedWarning",
     "ResourceNeatWarning",
     "ResourcesDuplicatedWarning",
     "RegexViolationWarning",
@@ -64,6 +69,7 @@ __all__ = [
     "NotSupportedViewContainerLimitWarning",
     "NotSupportedHasDataFilterLimitWarning",
     "UndefinedViewWarning",
+    "AuthWarning",
     "user_modeling",
 ]
 

cognite/neat/_issues/warnings/_external.py

@@ -38,3 +38,11 @@ class FileItemNotSupportedWarning(NeatWarning):
 
     item: str
     filepath: Path
+
+
+@dataclass(unsafe_hash=True)
+class AuthWarning(NeatWarning):
+    """Failed to {action} due to {reason}"""
+
+    action: str
+    reason: str

cognite/neat/_issues/warnings/_models.py

@@ -92,6 +92,15 @@ class NotSupportedHasDataFilterLimitWarning(CDFNotSupportedWarning):
     limit: int = DMS_VIEW_CONTAINER_SIZE_LIMIT
 
 
+@dataclass(unsafe_hash=True)
+class UndefinedClassWarning(UserModelingWarning):
+    """Class {class_id} has no explicit properties defined neither implements other class"""
+
+    fix = "Define properties for class or inherit properties by implementing another class."
+
+    class_id: str
+
+
 @dataclass(unsafe_hash=True)
 class UndefinedViewWarning(UserModelingWarning):
     """Undefined view {value_type} has been referred as value type for property <{view_property}> of view {view_id}."""

cognite/neat/_issues/warnings/_properties.py

@@ -54,3 +54,19 @@ class PropertyValueTypeUndefinedWarning(PropertyWarning[T_Identifier]):
 
     default_action: str
     recommended_action: str | None = None
+
+
+@dataclass(unsafe_hash=True)
+class PropertyOverwritingWarning(PropertyWarning[T_Identifier]):
+    """Overwriting the {overwriting} for {property_name} in the {resource_type}
+    with identifier {identifier}."""
+
+    overwriting: tuple[str, ...]
+
+
+@dataclass(unsafe_hash=True)
+class PropertySkippedWarning(PropertyWarning[T_Identifier]):
+    """The {resource_type} with identifier {identifier} has a property {property_name}
+    which is skipped. {reason}."""
+
+    reason: str

cognite/neat/_rules/_constants.py

@@ -1,6 +1,7 @@
 import re
 import sys
 from functools import cached_property
+from typing import Literal
 
 if sys.version_info >= (3, 11):
     from enum import StrEnum
@@ -42,7 +43,7 @@ class EntityTypes(StrEnum):
     space = "space"
 
 
-def get_reserved_words() -> dict[str, list[str]]:
+def get_reserved_words(key: Literal["class", "view", "property", "space"]) -> list[str]:
     return {
         "class": ["Class", "class"],
         "view": [
@@ -82,7 +83,7 @@ def get_reserved_words() -> dict[str, list[str]]:
             "extensions",
         ],
         "space": ["space", "cdf", "dms", "pg3", "shared", "system", "node", "edge"],
-    }
+    }[key]
 
 
 ENTITY_PATTERN = re.compile(r"^(?P<prefix>.*?):?(?P<suffix>[^(:]*)(\((?P<content>.+)\))?$")
@@ -93,20 +94,20 @@ MORE_THAN_ONE_NONE_ALPHANUMERIC_REGEX = r"([_-]{2,})"
 PREFIX_COMPLIANCE_REGEX = r"^([a-zA-Z]+)([a-zA-Z0-9]*[_-]{0,1}[a-zA-Z0-9_-]*)([a-zA-Z0-9]*)$"
 
 SPACE_COMPLIANCE_REGEX = (
-    rf"(?!^({'|'.join(get_reserved_words()['space'])})$)" r"(^[a-zA-Z][a-zA-Z0-9_-]{0,41}[a-zA-Z0-9]?$)"
+    rf"(?!^({'|'.join(get_reserved_words('space'))})$)" r"(^[a-zA-Z][a-zA-Z0-9_-]{0,41}[a-zA-Z0-9]?$)"
 )
 
 
 DATA_MODEL_COMPLIANCE_REGEX = r"^[a-zA-Z]([a-zA-Z0-9_]{0,253}[a-zA-Z0-9])?$"
 
 VIEW_ID_COMPLIANCE_REGEX = (
-    rf"(?!^({'|'.join(get_reserved_words()['view'])})$)" r"(^[a-zA-Z][a-zA-Z0-9_]{0,253}[a-zA-Z0-9]?$)"
+    rf"(?!^({'|'.join(get_reserved_words('view'))})$)" r"(^[a-zA-Z][a-zA-Z0-9_]{0,253}[a-zA-Z0-9]?$)"
 )
 DMS_PROPERTY_ID_COMPLIANCE_REGEX = (
-    rf"(?!^({'|'.join(get_reserved_words()['property'])})$)" r"(^[a-zA-Z][a-zA-Z0-9_]{0,253}[a-zA-Z0-9]?$)"
+    rf"(?!^({'|'.join(get_reserved_words('property'))})$)" r"(^[a-zA-Z][a-zA-Z0-9_]{0,253}[a-zA-Z0-9]?$)"
 )
 CLASS_ID_COMPLIANCE_REGEX = (
-    rf"(?!^({'|'.join(get_reserved_words()['class'])})$)" r"(^[a-zA-Z][a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
+    rf"(?!^({'|'.join(get_reserved_words('class'))})$)" r"(^[a-zA-Z][a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
 )
 
 INFORMATION_PROPERTY_ID_COMPLIANCE_REGEX = (

cognite/neat/_rules/_shared.py

@@ -4,20 +4,15 @@ from typing import Any, Generic, TypeAlias, TypeVar
 
 from cognite.neat._issues import IssueList
 from cognite.neat._rules.models import (
-    AssetRules,
     DMSRules,
-    DomainRules,
     InformationRules,
 )
-from cognite.neat._rules.models.asset._rules_input import AssetInputRules
 from cognite.neat._rules.models.dms._rules_input import DMSInputRules
 from cognite.neat._rules.models.information._rules_input import InformationInputRules
 
-VerifiedRules: TypeAlias = DomainRules | InformationRules | DMSRules | AssetRules
-InputRules: TypeAlias = AssetInputRules | DMSInputRules | InformationInputRules
-Rules: TypeAlias = (
-    AssetInputRules | DMSInputRules | InformationInputRules | DomainRules | InformationRules | DMSRules | AssetRules
-)
+VerifiedRules: TypeAlias = InformationRules | DMSRules
+InputRules: TypeAlias = DMSInputRules | InformationInputRules
+Rules: TypeAlias = DMSInputRules | InformationInputRules | InformationRules | DMSRules
 T_Rules = TypeVar("T_Rules", bound=Rules)
 T_VerifiedRules = TypeVar("T_VerifiedRules", bound=VerifiedRules)
 T_InputRules = TypeVar("T_InputRules", bound=InputRules)

cognite/neat/_rules/analysis/__init__.py

@@ -1,5 +1,4 @@
-from ._asset import AssetAnalysis
 from ._dms import DMSAnalysis
 from ._information import InformationAnalysis
 
-__all__ = ["InformationAnalysis", "AssetAnalysis", "DMSAnalysis"]
+__all__ = ["InformationAnalysis", "DMSAnalysis"]

cognite/neat/_rules/analysis/_base.py

@@ -14,7 +14,6 @@ from cognite.neat._rules.models._rdfpath import RDFPath
 from cognite.neat._rules.models.entities import (
     ClassEntity,
     Entity,
-    ReferenceEntity,
 )
 from cognite.neat._rules.models.information import InformationProperty
 from cognite.neat._utils.rdf_ import get_inheritance_path
@@ -76,10 +75,6 @@ class BaseAnalysis(ABC, Generic[T_Rules, T_Class, T_Property, T_ClassEntity, T_P
     def _get_properties(self) -> list[T_Property]:
         raise NotImplementedError
 
-    @abstractmethod
-    def _get_reference(self, class_or_property: T_Class | T_Property) -> ReferenceEntity | None:
-        raise NotImplementedError
-
     @abstractmethod
     def _get_cls_entity(self, class_: T_Class | T_Property) -> T_ClassEntity:
         raise NotImplementedError
@@ -92,10 +87,6 @@ class BaseAnalysis(ABC, Generic[T_Rules, T_Class, T_Property, T_ClassEntity, T_P
     def _get_cls_parents(self, class_: T_Class) -> list[T_ClassEntity] | None:
         raise NotImplementedError
 
-    @abstractmethod
-    def _get_reference_rules(self) -> T_Rules | None:
-        raise NotImplementedError
-
     @classmethod
     @abstractmethod
     def _set_cls_entity(cls, property_: T_Property, class_: T_ClassEntity) -> None:
@@ -111,33 +102,21 @@ class BaseAnalysis(ABC, Generic[T_Rules, T_Class, T_Property, T_ClassEntity, T_P
 
     @property
     def directly_referred_classes(self) -> set[ClassEntity]:
-        ref_rules = self._get_reference_rules()
-        if ref_rules is None:
-            return set()
-        prefix = ref_rules.metadata.get_prefix()
-        return {
-            ref.as_class_entity()
-            for class_ in self._get_classes()
-            if isinstance((ref := self._get_reference(class_)), ReferenceEntity) and ref.prefix == prefix
-        }
+        raise NotImplementedError
 
     @property
     def inherited_referred_classes(self) -> set[ClassEntity]:
-        dir_referred_classes = self.directly_referred_classes
-        inherited_referred_classes = []
-        for class_ in dir_referred_classes:
-            inherited_referred_classes.extend(self.class_inheritance_path(class_))
-        return set(inherited_referred_classes)
+        raise NotImplementedError
 
     # Todo Lru cache this method.
-    def class_parent_pairs(self) -> dict[T_ClassEntity, list[T_ClassEntity]]:
+    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"""
         class_subclass_pairs: dict[T_ClassEntity, list[T_ClassEntity]] = {}
         for cls_ in self._get_classes():
             entity = self._get_cls_entity(cls_)
             class_subclass_pairs[entity] = []
             for parent in self._get_cls_parents(cls_) or []:
-                if parent.prefix == entity.prefix:
+                if parent.prefix == entity.prefix or allow_different_space:
                     class_subclass_pairs[entity].append(parent)
                 else:
                     warnings.warn(
@@ -147,11 +126,15 @@ class BaseAnalysis(ABC, Generic[T_Rules, T_Class, T_Property, T_ClassEntity, T_P
 
         return class_subclass_pairs
 
-    def classes_with_properties(self, consider_inheritance: bool = False) -> dict[T_ClassEntity, list[T_Property]]:
+    def classes_with_properties(
+        self, consider_inheritance: bool = False, allow_different_namespace: bool = False
+    ) -> dict[T_ClassEntity, list[T_Property]]:
         """Returns classes that have been defined in the data model.
 
         Args:
             consider_inheritance: Whether to consider inheritance or not. Defaults False
+            allow_different_namespace: When considering inheritance, whether to allow parents from
+                different namespaces or not. Defaults False
 
         Returns:
             Dictionary of classes with a list of properties defined for them
@@ -171,7 +154,7 @@ class BaseAnalysis(ABC, Generic[T_Rules, T_Class, T_Property, T_ClassEntity, T_P
             class_property_pairs[self._get_cls_entity(property_)].append(property_)  # type: ignore
 
         if consider_inheritance:
-            class_parent_pairs = self.class_parent_pairs()
+            class_parent_pairs = self.class_parent_pairs(allow_different_namespace)
             for class_ in class_parent_pairs:
                 self._add_inherited_properties(class_, class_property_pairs, class_parent_pairs)
 

cognite/neat/_rules/analysis/_dms.py

@@ -1,6 +1,6 @@
 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 ReferenceEntity, ViewEntity
+from cognite.neat._rules.models.entities import ViewEntity
 
 from ._base import BaseAnalysis
 
@@ -14,21 +14,12 @@ class DMSAnalysis(BaseAnalysis[DMSRules, DMSView, DMSProperty, ViewEntity, str])
     def _get_properties(self) -> list[DMSProperty]:
         return list(self.rules.properties)
 
-    def _get_reference(self, class_or_property: DMSView | DMSProperty) -> ReferenceEntity | None:
-        return class_or_property.reference if isinstance(class_or_property.reference, ReferenceEntity) else None
-
     def _get_cls_entity(self, class_: DMSView | DMSProperty) -> ViewEntity:
         return class_.view
 
-    def _get_prop_entity(self, property_: DMSProperty) -> str:
-        return property_.property_
-
     def _get_cls_parents(self, class_: DMSView) -> list[ViewEntity] | None:
         return list(class_.implements) if class_.implements else None
 
-    def _get_reference_rules(self) -> DMSRules | None:
-        return self.rules.reference
-
     @classmethod
     def _set_cls_entity(cls, property_: DMSProperty, class_: ViewEntity) -> None:
         property_.view = class_
@@ -41,3 +32,6 @@ class DMSAnalysis(BaseAnalysis[DMSRules, DMSView, DMSProperty, ViewEntity, str])
 
     def subset_rules(self, desired_classes: set[ViewEntity]) -> DMSRules:
         raise NotImplementedError()
+
+    def _get_prop_entity(self, property_: DMSProperty) -> str:
+        return property_.view_property

cognite/neat/_rules/analysis/_information.py

@@ -12,7 +12,7 @@ from cognite.neat._rules.models._rdfpath import (
     SelfReferenceProperty,
     SingleProperty,
 )
-from cognite.neat._rules.models.entities import ClassEntity, ReferenceEntity
+from cognite.neat._rules.models.entities import ClassEntity
 from cognite.neat._rules.models.entities._multi_value import MultiValueTypeInfo
 from cognite.neat._rules.models.information import (
     InformationClass,
@@ -34,9 +34,6 @@ class InformationAnalysis(BaseAnalysis[InformationRules, InformationClass, Infor
     def _get_max_occurrence(self, property_: InformationProperty) -> int | float | None:
         return property_.max_count
 
-    def _get_reference(self, class_or_property: InformationClass | InformationProperty) -> ReferenceEntity | None:
-        return class_or_property.reference if isinstance(class_or_property.reference, ReferenceEntity) else None
-
     def _get_cls_entity(self, class_: InformationClass | InformationProperty) -> ClassEntity:
         return class_.class_
 
@@ -48,10 +45,7 @@ class InformationAnalysis(BaseAnalysis[InformationRules, InformationClass, Infor
         return property_.property_
 
     def _get_cls_parents(self, class_: InformationClass) -> list[ClassEntity] | None:
-        return list(class_.parent or []) or None
-
-    def _get_reference_rules(self) -> InformationRules | None:
-        return self.rules.reference
+        return list(class_.implements or []) or None
 
     def _get_properties(self) -> list[InformationProperty]:
         return list(self.rules.properties)
@@ -154,8 +148,6 @@ class InformationAnalysis(BaseAnalysis[InformationRules, InformationClass, Infor
             If it fails, it will return a partial rules with a warning message, validated
             only with base Pydantic validators.
         """
-        if self.rules.metadata.schema_ is not SchemaCompleteness.complete:
-            raise ValueError("Rules are not complete cannot perform reduction!")
         class_as_dict = self.as_class_dict()
         class_parents_pairs = self.class_parent_pairs()
         defined_classes = self.defined_classes(consider_inheritance=True)

cognite/neat/_rules/exporters/_base.py

@@ -3,8 +3,7 @@ from collections.abc import Iterable
 from pathlib import Path
 from typing import Generic, TypeVar
 
-from cognite.client import CogniteClient
-
+from cognite.neat._client import NeatClient
 from cognite.neat._rules._shared import T_VerifiedRules
 from cognite.neat._utils.auxiliary import class_html_doc
 from cognite.neat._utils.upload import UploadResult, UploadResultList
@@ -32,11 +31,11 @@ class BaseExporter(ABC, Generic[T_VerifiedRules, T_Export]):
 class CDFExporter(BaseExporter[T_VerifiedRules, T_Export]):
     @abstractmethod
     def export_to_cdf_iterable(
-        self, rules: T_VerifiedRules, client: CogniteClient, dry_run: bool = False, fallback_one_by_one: bool = False
+        self, rules: T_VerifiedRules, client: NeatClient, dry_run: bool = False, fallback_one_by_one: bool = False
     ) -> Iterable[UploadResult]:
         raise NotImplementedError
 
     def export_to_cdf(
-        self, rules: T_VerifiedRules, client: CogniteClient, dry_run: bool = False, fallback_one_by_one: bool = False
+        self, rules: T_VerifiedRules, client: NeatClient, dry_run: bool = False, fallback_one_by_one: bool = False
     ) -> UploadResultList:
         return UploadResultList(self.export_to_cdf_iterable(rules, client, dry_run, fallback_one_by_one))