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

cognite/neat/_graph/loaders/_rdf2dms.py

@@ -14,19 +14,21 @@ 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
 from cognite.neat._issues.errors import (
-    ResourceConvertionError,
+    ResourceConversionError,
     ResourceCreationError,
     ResourceDuplicatedError,
     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(
@@ -88,14 +92,24 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             data_model = rules.as_schema().as_read_model()
         except Exception as e:
             issues.append(
-                ResourceConvertionError(
+                ResourceConversionError(
                     identifier=rules.metadata.as_identifier(),
                     resource_type="DMS Rules",
                     target_format="read DMS model",
                     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,39 +242,48 @@ 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(
-        {"source_external_id", "target_external_id", "external_id", "source_type", "target_type"}
+        {"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}>
 
 SELECT (COUNT(?instance) AS ?instanceCount)
 WHERE {{
   ?instance a classic:Relationship .
-  ?instance classic:source_type classic:{source_type} .
-  ?instance classic:target_type classic:{target_type} .
+  ?instance classic:sourceType classic:{source_type} .
+  ?instance classic:targetType classic:{target_type} .
 }}"""
 
     _instances = """PREFIX classic: <{namespace}>
@@ -275,58 +291,110 @@ WHERE {{
 SELECT ?instance
 WHERE {{
     ?instance a classic:Relationship .
-    ?instance classic:source_type classic:{source_type} .
-    ?instance classic:target_type classic:{target_type} .
+    ?instance classic:sourceType classic:{source_type} .
+    ?instance classic:targetType classic:{target_type} .
 }}"""
     _lookup_entity_query = """PREFIX classic: <{namespace}>
 
 SELECT ?entity
 WHERE {{
     ?entity a classic:{entity_type} .
-    ?entity classic:external_id "{external_id}" .
+    ?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["source_external_id"])
-        target_source_id = cast(URIRef, object_by_predicates["target_external_id"])
+        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["external_id"])
+            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,27 +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 new node
-        instance_id = self._namespace[external_id]
-        graph.add((instance_id, RDF.type, self._namespace["Edge"]))
+        # Create the entity with the properties
+        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_))
-
-        # Connect the new node to the source and target nodes
-        graph.add((source_id, predicate, instance_id))
-        graph.add((instance_id, self._namespace["end_node"], target_id))
+            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 <-> Edge -> TimeSeries
+        # and the new edge will point to the asset and the timeseries through startNode and endNode
+
+        # 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/_base.py

@@ -210,7 +210,7 @@ class NeatError(NeatIssue, Exception):
     """This is the base class for all exceptions (errors) used in Neat."""
 
     @classmethod
-    def from_pydantic_errors(cls, errors: list[ErrorDetails], **kwargs) -> "list[NeatError]":
+    def from_errors(cls, errors: "list[ErrorDetails | NeatError]", **kwargs) -> "list[NeatError]":
         """Convert a list of pydantic errors to a list of Error instances.
 
         This is intended to be overridden in subclasses to handle specific error types.
@@ -219,24 +219,36 @@ class NeatError(NeatIssue, Exception):
         read_info_by_sheet = kwargs.get("read_info_by_sheet")
 
         for error in errors:
-            if error["type"] == "is_instance_of" and error["loc"][1] == "is-instance[SheetList]":
+            if (
+                isinstance(error, dict)
+                and error["type"] == "is_instance_of"
+                and error["loc"][1] == "is-instance[SheetList]"
+            ):
                 # Skip the error for SheetList, as it is not relevant for the user. This is an
                 # internal class used to have helper methods for a lists as .to_pandas()
                 continue
-            ctx = error.get("ctx")
-            if isinstance(ctx, dict) and isinstance(multi_error := ctx.get("error"), MultiValueError):
+            neat_error: NeatError | None = None
+            if isinstance(error, dict) and isinstance(ctx := error.get("ctx"), dict) and "error" in ctx:
+                neat_error = ctx["error"]
+            elif isinstance(error, NeatError | MultiValueError):
+                neat_error = error
+
+            if isinstance(neat_error, MultiValueError):
                 if read_info_by_sheet:
-                    for caught_error in multi_error.errors:
+                    for caught_error in neat_error.errors:
                         cls._adjust_row_numbers(caught_error, read_info_by_sheet)  # type: ignore[arg-type]
-                all_errors.extend(multi_error.errors)  # type: ignore[arg-type]
-            elif isinstance(ctx, dict) and isinstance(single_error := ctx.get("error"), NeatError):
+                all_errors.extend(neat_error.errors)  # type: ignore[arg-type]
+            elif isinstance(neat_error, NeatError):
                 if read_info_by_sheet:
-                    cls._adjust_row_numbers(single_error, read_info_by_sheet)
-                all_errors.append(single_error)
-            elif len(error["loc"]) >= 4 and read_info_by_sheet:
+                    cls._adjust_row_numbers(neat_error, read_info_by_sheet)
+                all_errors.append(neat_error)
+            elif isinstance(error, dict) and len(error["loc"]) >= 4 and read_info_by_sheet:
                 all_errors.append(RowError.from_pydantic_error(error, read_info_by_sheet))
-            else:
+            elif isinstance(error, dict):
                 all_errors.append(DefaultPydanticError.from_pydantic_error(error))
+            else:
+                # This is unreachable. However, in case it turns out to be reachable, we want to know about it.
+                raise ValueError(f"Unsupported error type: {error}")
         return all_errors
 
     @staticmethod
@@ -511,13 +523,10 @@ def catch_issues(
         try:
             yield future_result
         except ValidationError as e:
-            issues.extend(error_cls.from_pydantic_errors(e.errors(), **(error_args or {})))
-            future_result._result = "failure"
-        except MultiValueError as e:
-            issues.extend(e.errors)
+            issues.extend(error_cls.from_errors(e.errors(), **(error_args or {})))  # type: ignore[arg-type]
             future_result._result = "failure"
-        except NeatError as e:
-            issues.append(e)
+        except (NeatError, MultiValueError) as e:
+            issues.extend(error_cls.from_errors([e], **(error_args or {})))  # type: ignore[arg-type, list-item]
             future_result._result = "failure"
         else:
             future_result._result = "success"

cognite/neat/_issues/errors/__init__.py

@@ -2,6 +2,7 @@ from cognite.neat._issues._base import DefaultPydanticError, NeatError, RowError
 
 from ._external import (
     AuthorizationError,
+    CDFMissingClientError,
     FileMissingRequiredFieldError,
     FileNotAFileError,
     FileNotFoundNeatError,
@@ -20,7 +21,7 @@ from ._properties import (
 )
 from ._resources import (
     ResourceChangedError,
-    ResourceConvertionError,
+    ResourceConversionError,
     ResourceCreationError,
     ResourceDuplicatedError,
     ResourceError,
@@ -58,7 +59,7 @@ __all__ = [
     "ResourceError",
     "ResourceNotDefinedError",
     "ResourceMissingIdentifierError",
-    "ResourceConvertionError",
+    "ResourceConversionError",
     "WorkflowConfigurationNotSetError",
     "WorkFlowMissingDataError",
     "WorkflowStepNotInitializedError",
@@ -70,6 +71,7 @@ __all__ = [
     "RowError",
     "NeatTypeError",
     "ReversedConnectionNotFeasibleError",
+    "CDFMissingClientError",
 ]
 
 _NEAT_ERRORS_BY_NAME = {error.__name__: error for error in _get_subclasses(NeatError, include_base=True)}

cognite/neat/_issues/errors/_external.py

@@ -65,3 +65,10 @@ class FileNotAFileError(NeatError, FileNotFoundError):
 
     fix = "Make sure to provide a valid file"
     filepath: Path
+
+
+@dataclass(unsafe_hash=True)
+class CDFMissingClientError(NeatError, RuntimeError):
+    """CDF client is required: {reason}"""
+
+    reason: str

cognite/neat/_issues/errors/_properties.py

@@ -34,14 +34,9 @@ class PropertyTypeNotSupportedError(PropertyError[T_Identifier]):
 
 @dataclass(unsafe_hash=True)
 class ReversedConnectionNotFeasibleError(PropertyError[T_Identifier]):
-    """The {resource_type} {property_name} with identifier {identifier} of the view {target_view_id} cannot be made
-    since view {source_view_id} does not have direct connection {direct_connection} defined,
-    or {direct_connection} value type is not {target_view_id}
-    """
+    """The {resource_type} {identifier}.{property_name} cannot be created: {reason}"""
 
-    target_view_id: str
-    source_view_id: str
-    direct_connection: str
+    reason: str
 
 
 # This is a generic error that should be used sparingly

cognite/neat/_issues/errors/_resources.py

@@ -64,7 +64,7 @@ class ResourceNotDefinedError(ResourceError[T_Identifier]):
 
 
 @dataclass(unsafe_hash=True)
-class ResourceConvertionError(ResourceError, ValueError):
+class ResourceConversionError(ResourceError, ValueError):
     """Failed to convert the {resource_type} {identifier} to {target_format}: {reason}"""
 
     fix = "Check the error message and correct the rules."

cognite/neat/_issues/warnings/__init__.py

@@ -6,7 +6,8 @@ from cognite.neat._issues._base import DefaultWarning, NeatWarning, _get_subclas
 
 from . import user_modeling
 from ._external import (
-    AuthWarning,
+    CDFAuthWarning,
+    CDFMaxIterationsWarning,
     FileItemNotSupportedWarning,
     FileMissingRequiredFieldWarning,
     FileReadWarning,
@@ -35,6 +36,7 @@ from ._properties import (
 from ._resources import (
     ResourceNeatWarning,
     ResourceNotFoundWarning,
+    ResourceRegexViolationWarning,
     ResourceRetrievalWarning,
     ResourcesDuplicatedWarning,
     ResourceTypeNotSupportedWarning,
@@ -63,14 +65,16 @@ __all__ = [
     "ResourceNotFoundWarning",
     "ResourceTypeNotSupportedWarning",
     "ResourceRetrievalWarning",
+    "ResourceRegexViolationWarning",
     "PrincipleOneModelOneSpaceWarning",
     "PrincipleMatchingSpaceAndVersionWarning",
     "PrincipleSolutionBuildsOnEnterpriseWarning",
     "NotSupportedViewContainerLimitWarning",
     "NotSupportedHasDataFilterLimitWarning",
     "UndefinedViewWarning",
-    "AuthWarning",
+    "CDFAuthWarning",
     "user_modeling",
+    "CDFMaxIterationsWarning",
 ]
 
 _NEAT_WARNINGS_BY_NAME = {warning.__name__: warning for warning in _get_subclasses(NeatWarning, include_base=True)}

cognite/neat/_issues/warnings/_external.py

@@ -41,8 +41,16 @@ class FileItemNotSupportedWarning(NeatWarning):
 
 
 @dataclass(unsafe_hash=True)
-class AuthWarning(NeatWarning):
+class CDFAuthWarning(NeatWarning):
     """Failed to {action} due to {reason}"""
 
     action: str
     reason: str
+
+
+@dataclass(unsafe_hash=True)
+class CDFMaxIterationsWarning(NeatWarning):
+    """The maximum number of iterations ({max_iterations}) has been reached. {message}"""
+
+    message: str
+    max_iterations: int