cognite-neat 0.88.1__tar.gz → 0.88.3__tar.gz

{cognite_neat-0.88.1 → cognite_neat-0.88.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cognite-neat
-Version: 0.88.1
+Version: 0.88.3
 Summary: Knowledge graph transformation
 Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0

cognite_neat-0.88.3/cognite/neat/_version.py

@@ -0,0 +1 @@
+__version__ = "0.88.3"

{cognite_neat-0.88.1 → cognite_neat-0.88.3}/cognite/neat/graph/loaders/_base.py

@@ -6,9 +6,9 @@ from typing import ClassVar, Generic, TypeVar
 from cognite.client import CogniteClient
 from cognite.client.data_classes.capabilities import Capability
 
-from cognite.neat.graph import NeatGraphStore
-from cognite.neat.graph.issues.loader import FailedAuthorizationError
-from cognite.neat.issues import NeatIssue, NeatIssueList
+from cognite.neat.issues import IssueList, NeatIssue, NeatIssueList
+from cognite.neat.issues.errors import AuthorizationError
+from cognite.neat.store import NeatGraphStore
 from cognite.neat.utils.auxiliary import class_html_doc
 from cognite.neat.utils.upload import UploadResult, UploadResultList
 
@@ -61,12 +61,12 @@ class CDFLoader(BaseLoader[T_Output]):
             if missing_capabilities:
                 upload_result = UploadResult[Hashable](name=type(self).__name__)
                 upload_result.issues.append(
-                    FailedAuthorizationError(action="Upload to CDF", reason=str(missing_capabilities))
+                    AuthorizationError(action="Upload to CDF", reason=str(missing_capabilities))
                 )
                 yield upload_result
                 return
 
-        issues = NeatIssueList[NeatIssue]()
+        issues = IssueList()
         items: list[T_Output] = []
         for result in self._load(stop_on_exception=False):
             if isinstance(result, NeatIssue):
@@ -79,7 +79,7 @@ class CDFLoader(BaseLoader[T_Output]):
 
             if len(items) >= self._UPLOAD_BATCH_SIZE or result is _END_OF_CLASS:
                 yield from self._upload_to_cdf(client, items, dry_run, issues)
-                issues = NeatIssueList[NeatIssue]()
+                issues = IssueList()
                 items = []
         if items:
             yield from self._upload_to_cdf(client, items, dry_run, issues)

{cognite_neat-0.88.1 → cognite_neat-0.88.3}/cognite/neat/graph/loaders/_rdf2asset.py

@@ -19,12 +19,12 @@ from cognite.client.exceptions import CogniteAPIError, CogniteDuplicatedError
 
 from cognite.neat.graph._tracking.base import Tracker
 from cognite.neat.graph._tracking.log import LogTracker
-from cognite.neat.graph.issues import loader as loader_issues
-from cognite.neat.graph.stores import NeatGraphStore
-from cognite.neat.issues import NeatIssue, NeatIssueList
+from cognite.neat.issues import IssueList, NeatError, NeatIssue, NeatIssueList
+from cognite.neat.issues.errors import ResourceCreationError, ResourceNotFoundError
 from cognite.neat.rules.analysis._asset import AssetAnalysis
 from cognite.neat.rules.models import AssetRules
 from cognite.neat.rules.models.entities import ClassEntity, EntityTypes
+from cognite.neat.store import NeatGraphStore
 from cognite.neat.utils.auxiliary import create_sha256_hash
 from cognite.neat.utils.upload import UploadResult
 
@@ -80,7 +80,7 @@ class AssetLoader(CDFLoader[AssetWrite]):
         self.external_id_prefix = external_id_prefix
 
         self.processed_assets: set[str] = set()
-        self._issues = NeatIssueList[NeatIssue](create_issues or [])
+        self._issues = IssueList(create_issues or [])
         self._tracker: type[Tracker] = tracker or LogTracker
 
     def _load(self, stop_on_exception: bool = False) -> Iterable[AssetWrite | NeatIssue | type[_END_OF_CLASS]]:
@@ -122,6 +122,7 @@ class AssetLoader(CDFLoader[AssetWrite]):
         tracker: Tracker,
         stop_on_exception: bool,
     ) -> Iterable[Any]:
+        error: NeatError
         for class_ in ordered_classes:
             tracker.start(repr(class_.id))
 
@@ -143,20 +144,18 @@ class AssetLoader(CDFLoader[AssetWrite]):
 
                 # check on parent
                 if "parentExternalId" in fields and fields["parentExternalId"] not in self.processed_assets:
-                    error = loader_issues.InvalidInstanceError(
-                        type_=EntityTypes.asset,
-                        identifier=identifier,
-                        reason=(
-                            f"Parent asset {fields['parentExternalId']} does not exist or failed creation"
-                            f""" {
-                                f', moving the asset {identifier} under orphanage {self.orphanage.external_id}'
-                                if self.orphanage
-                                else ''}"""
-                        ),
+                    error = ResourceNotFoundError(
+                        fields["parentExternalId"],
+                        EntityTypes.asset,
+                        identifier,
+                        EntityTypes.asset,
+                        f"Moving the asset {identifier} under orphanage {self.orphanage.external_id}"
+                        if self.orphanage
+                        else "",
                     )
                     tracker.issue(error)
                     if stop_on_exception:
-                        raise error.as_exception()
+                        raise error
                     yield error
 
                     # if orphanage is set asset will use orphanage as parent
@@ -171,12 +170,10 @@ class AssetLoader(CDFLoader[AssetWrite]):
                     yield AssetWrite.load(fields)
                     self.processed_assets.add(identifier)
                 except KeyError as e:
-                    error = loader_issues.InvalidInstanceError(
-                        type_=EntityTypes.asset, identifier=identifier, reason=str(e)
-                    )
+                    error = ResourceCreationError(identifier, EntityTypes.asset, error=str(e))
                     tracker.issue(error)
                     if stop_on_exception:
-                        raise error.as_exception() from e
+                        raise error from e
                     yield error
 
             yield _END_OF_CLASS
@@ -203,17 +200,17 @@ class AssetLoader(CDFLoader[AssetWrite]):
 
                 # check if source asset exists
                 if source_external_id not in self.processed_assets:
-                    error = loader_issues.InvalidInstanceError(
-                        type_=EntityTypes.relationship,
+                    error = ResourceCreationError(
+                        resource_type=EntityTypes.relationship,
                         identifier=source_external_id,
-                        reason=(
+                        error=(
                             f"Asset {source_external_id} does not exist! "
                             "Aborting creation of relationships which use this asset as the source."
                         ),
                     )
                     tracker.issue(error)
                     if stop_on_exception:
-                        raise error.as_exception()
+                        raise error
                     yield error
                     continue
 
@@ -223,10 +220,10 @@ class AssetLoader(CDFLoader[AssetWrite]):
                         target_external_id = f"{self.external_id_prefix or ''}{target_external_id}"
                         # check if source asset exists
                         if target_external_id not in self.processed_assets:
-                            error = loader_issues.InvalidInstanceError(
-                                type_=EntityTypes.relationship,
+                            error = ResourceCreationError(
+                                resource_type=EntityTypes.relationship,
                                 identifier=target_external_id,
-                                reason=(
+                                error=(
                                     f"Asset {target_external_id} does not exist! "
                                     f"Cannot create relationship between {source_external_id}"
                                     f" and {target_external_id}. "
@@ -234,7 +231,7 @@ class AssetLoader(CDFLoader[AssetWrite]):
                             )
                             tracker.issue(error)
                             if stop_on_exception:
-                                raise error.as_exception()
+                                raise error
                             yield error
                             continue
 
@@ -250,14 +247,14 @@ class AssetLoader(CDFLoader[AssetWrite]):
                                 labels=[label] if self.use_labels else None,
                             )
                         except KeyError as e:
-                            error = loader_issues.InvalidInstanceError(
-                                type_=EntityTypes.relationship,
+                            error = ResourceCreationError(
+                                resource_type=EntityTypes.relationship,
                                 identifier=external_id,
-                                reason=str(e),
+                                error=str(e),
                             )
                             tracker.issue(error)
                             if stop_on_exception:
-                                raise error.as_exception() from e
+                                raise error from e
                             yield error
 
             yield _END_OF_CLASS

{cognite_neat-0.88.1 → cognite_neat-0.88.3}/cognite/neat/graph/loaders/_rdf2dms.py

@@ -15,11 +15,17 @@ from cognite.client.exceptions import CogniteAPIError
 from pydantic import BaseModel, ValidationInfo, create_model, field_validator
 
 from cognite.neat.graph._tracking import LogTracker, Tracker
-from cognite.neat.graph.issues import loader as loader_issues
-from cognite.neat.graph.stores import NeatGraphStore
-from cognite.neat.issues import NeatIssue, NeatIssueList
+from cognite.neat.issues import IssueList, NeatIssue, NeatIssueList
+from cognite.neat.issues.errors import (
+    ResourceConvertionError,
+    ResourceCreationError,
+    ResourceDuplicatedError,
+    ResourceRetrievalError,
+)
+from cognite.neat.issues.warnings import PropertyTypeNotSupportedWarning
 from cognite.neat.rules.models import DMSRules
 from cognite.neat.rules.models.data_types import _DATA_TYPE_BY_DMS_TYPE, Json
+from cognite.neat.store import NeatGraphStore
 from cognite.neat.utils.auxiliary import create_sha256_hash
 from cognite.neat.utils.upload import UploadResult
 
@@ -51,7 +57,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         self.data_model = data_model
         self.instance_space = instance_space
         self.class_by_view_id = class_by_view_id or {}
-        self._issues = NeatIssueList[NeatIssue](create_issues or [])
+        self._issues = IssueList(create_issues or [])
         self._tracker: type[Tracker] = tracker or LogTracker
 
     @classmethod
@@ -67,7 +73,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         try:
             data_model = client.data_modeling.data_models.retrieve(data_model_id, inline_views=True).latest_version()
         except Exception as e:
-            issues.append(loader_issues.MissingDataModelError(identifier=repr(data_model_id), reason=str(e)))
+            issues.append(ResourceRetrievalError(data_model_id, "data model", str(e)))
 
         return cls(graph_store, data_model, instance_space, {}, issues)
 
@@ -79,8 +85,9 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             data_model = rules.as_schema().as_read_model()
         except Exception as e:
             issues.append(
-                loader_issues.FailedConvertError(
+                ResourceConvertionError(
                     identifier=rules.metadata.as_identifier(),
+                    resource_type="DMS Rules",
                     target_format="read DMS model",
                     reason=str(e),
                 )
@@ -110,10 +117,10 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
                 try:
                     yield self._create_node(identifier, properties, pydantic_cls, view_id)
                 except ValueError as e:
-                    error = loader_issues.InvalidInstanceError(type_="node", identifier=identifier, reason=str(e))
+                    error = ResourceCreationError(identifier, "node", error=str(e))
                     tracker.issue(error)
                     if stop_on_exception:
-                        raise error.as_exception() from e
+                        raise error from e
                     yield error
                 yield from self._create_edges(identifier, properties, edge_by_properties, tracker)
             tracker.finish(repr(view_id))
@@ -141,7 +148,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
     def _create_validation_classes(
         self, view: dm.View
     ) -> tuple[type[BaseModel], dict[str, dm.EdgeConnection], NeatIssueList]:
-        issues = NeatIssueList[NeatIssue]()
+        issues = IssueList()
         field_definitions: dict[str, tuple[type, Any]] = {}
         edge_by_property: dict[str, dm.EdgeConnection] = {}
         validators: dict[str, classmethod] = {}
@@ -158,9 +165,11 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
                     data_type = _DATA_TYPE_BY_DMS_TYPE.get(prop.type._type)
                     if not data_type:
                         issues.append(
-                            loader_issues.InvalidClassWarning(
-                                class_name=repr(view.as_id()),
-                                reason=f"Unknown data type for property {prop_name}: {prop.type._type}",
+                            PropertyTypeNotSupportedWarning(
+                                view.as_id(),
+                                "view",
+                                prop_name,
+                                prop.type._type,
                             )
                         )
                         continue
@@ -247,10 +256,10 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
                 continue
             edge = edge_by_properties[prop]
             if isinstance(edge, SingleEdgeConnection) and len(values) > 1:
-                error = loader_issues.InvalidInstanceError(
-                    type_="edge",
+                error = ResourceDuplicatedError(
+                    resource_type="edge",
                     identifier=identifier,
-                    reason=f"Multiple values for single edge {edge}. Expected only one.",
+                    location=f"Multiple values for single edge {edge}. Expected only one.",
                 )
                 tracker.issue(error)
                 yield error

cognite_neat-0.88.3/cognite/neat/issues/__init__.py

@@ -0,0 +1,14 @@
+"""This is module contains all the Neat Exceptions (Errors) and Warnings as well
+as some helper classes to handle them like NeatIssueList"""
+
+from ._base import DefaultWarning, IssueList, MultiValueError, NeatError, NeatIssue, NeatIssueList, NeatWarning
+
+__all__ = [
+    "NeatIssue",
+    "NeatError",
+    "NeatWarning",
+    "DefaultWarning",
+    "NeatIssueList",
+    "IssueList",
+    "MultiValueError",
+]