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

cognite/neat/_graph/loaders/_rdf2dms.py

@@ -19,7 +19,7 @@ from rdflib import RDF
 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,
@@ -88,7 +88,7 @@ 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",

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}>}}"""
-
-    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))
+    _item_type = DEFAULT_NAMESPACE.TimeSeries
+    _default_attribute = DEFAULT_NAMESPACE.assetId
+    _connection_type = DEFAULT_NAMESPACE.timeSeries
 
 
-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
-
-    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))
+    _item_type = DEFAULT_NAMESPACE.File
+    _default_attribute = DEFAULT_NAMESPACE.assetIds
+    _connection_type = DEFAULT_NAMESPACE.file
 
 
-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(
@@ -338,7 +254,7 @@ class RelationshipToSchemaTransformer(BaseTransformer):
         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"
@@ -350,8 +266,8 @@ class RelationshipToSchemaTransformer(BaseTransformer):
 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}>
@@ -359,15 +275,15 @@ 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}" .
 }}"""
 
     def transform(self, graph: Graph) -> None:
@@ -393,8 +309,8 @@ WHERE {{
         object_by_predicates = cast(
             dict[str, URIRef | Literal], {remove_namespace_from_uri(row[1]): row[2] for row in result}
         )
-        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)
         except ValueError:
@@ -405,7 +321,7 @@ WHERE {{
         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"])
+        external_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))
 
@@ -431,7 +347,7 @@ WHERE {{
         predicate: URIRef,
     ) -> None:
         """Creates a new intermediate node for the relationship with properties."""
-        # Create new node
+        # Create the entity with the properties
         instance_id = self._namespace[external_id]
         graph.add((instance_id, RDF.type, self._namespace["Edge"]))
         for prop_name, object_ in objects_by_predicates.items():
@@ -439,9 +355,20 @@ WHERE {{
                 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))
+        # 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
+        # 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))
 
     def _predicate(self, target_type: str) -> URIRef:
         return self._namespace[f"relationship{target_type.capitalize()}"]

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/_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,6 +6,8 @@ from cognite.neat._issues._base import DefaultWarning, NeatWarning, _get_subclas
 
 from . import user_modeling
 from ._external import (
+    CDFAuthWarning,
+    CDFMaxIterationsWarning,
     FileItemNotSupportedWarning,
     FileMissingRequiredFieldWarning,
     FileReadWarning,
@@ -26,6 +28,8 @@ from ._models import (
 from ._properties import (
     PropertyDefinitionDuplicatedWarning,
     PropertyNotFoundWarning,
+    PropertyOverwritingWarning,
+    PropertySkippedWarning,
     PropertyTypeNotSupportedWarning,
     PropertyValueTypeUndefinedWarning,
 )
@@ -52,6 +56,8 @@ __all__ = [
     "PropertyTypeNotSupportedWarning",
     "PropertyNotFoundWarning",
     "PropertyValueTypeUndefinedWarning",
+    "PropertyOverwritingWarning",
+    "PropertySkippedWarning",
     "ResourceNeatWarning",
     "ResourcesDuplicatedWarning",
     "RegexViolationWarning",
@@ -64,7 +70,9 @@ __all__ = [
     "NotSupportedViewContainerLimitWarning",
     "NotSupportedHasDataFilterLimitWarning",
     "UndefinedViewWarning",
+    "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

@@ -38,3 +38,19 @@ class FileItemNotSupportedWarning(NeatWarning):
 
     item: str
     filepath: Path
+
+
+@dataclass(unsafe_hash=True)
+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

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