cognite-neat 0.88.2__py3-none-any.whl → 0.88.3__py3-none-any.whl

cognite/neat/rules/models/information/_validation.py

@@ -3,7 +3,7 @@ from collections import Counter
 from typing import cast
 
 from cognite.neat.issues import IssueList
-from cognite.neat.rules import issues
+from cognite.neat.issues.errors import NeatValueError, ResourceNotDefinedError
 from cognite.neat.rules.models._base import DataModelType, SchemaCompleteness
 from cognite.neat.rules.models.entities import ClassEntity, EntityTypes, UnknownEntity
 from cognite.neat.utils.rdf_ import get_inheritance_path
@@ -58,9 +58,9 @@ class InformationPostValidation:
                 ):
                     dangling_classes.add(class_)
 
-        if dangling_classes:
+        for class_ in dangling_classes:
             self.issue_list.append(
-                issues.spreadsheet.ClassNoPropertiesNoParentError([class_.versioned_id for class_ in dangling_classes])
+                NeatValueError(f"Class {class_} has no properties and is not a parent of any class with properties")
             )
 
     def _referenced_parent_classes_exist(self) -> None:
@@ -70,9 +70,15 @@ class InformationPostValidation:
         parents = set(itertools.chain.from_iterable(class_parent_pairs.values()))
 
         if undefined_parents := parents.difference(classes):
-            self.issue_list.append(
-                issues.spreadsheet.ParentClassesNotDefinedError([missing.versioned_id for missing in undefined_parents])
-            )
+            for parent in undefined_parents:
+                # Todo: include row and column number
+                self.issue_list.append(
+                    ResourceNotDefinedError[ClassEntity](
+                        resource_type="class",
+                        identifier=parent,
+                        location="Classes sheet",
+                    )
+                )
 
     def _referenced_classes_exist(self) -> None:
         # needs to be complete for this validation to pass
@@ -83,21 +89,27 @@ class InformationPostValidation:
         if self.metadata.schema_ == SchemaCompleteness.complete and (
             missing_classes := referred_classes.difference(defined_classes)
         ):
-            self.issue_list.append(
-                issues.spreadsheet.PropertiesDefinedForUndefinedClassesError(
-                    [missing.versioned_id for missing in missing_classes]
+            for class_ in missing_classes:
+                self.issue_list.append(
+                    ResourceNotDefinedError[ClassEntity](
+                        resource_type="class",
+                        identifier=class_,
+                        location="Classes sheet",
+                    )
                 )
-            )
 
         # USE CASE: models are extended (user + last = complete)
         if self.metadata.schema_ == SchemaCompleteness.extended:
             defined_classes |= {class_.class_ for class_ in cast(InformationRules, self.rules.last).classes}
             if missing_classes := referred_classes.difference(defined_classes):
-                self.issue_list.append(
-                    issues.spreadsheet.PropertiesDefinedForUndefinedClassesError(
-                        [missing.versioned_id for missing in missing_classes]
+                for class_ in missing_classes:
+                    self.issue_list.append(
+                        ResourceNotDefinedError[ClassEntity](
+                            resource_type="class",
+                            identifier=class_,
+                            location="Classes sheet",
+                        )
                     )
-                )
 
     def _referenced_value_types_exist(self) -> None:
         # adding UnknownEntity to the set of defined classes to handle the case where a property references an unknown
@@ -112,21 +124,29 @@ class InformationPostValidation:
         if self.metadata.schema_ == SchemaCompleteness.complete and (
             missing_value_types := referred_object_types.difference(defined_classes)
         ):
-            self.issue_list.append(
-                issues.spreadsheet.ValueTypeNotDefinedError(
-                    [cast(ClassEntity, missing).versioned_id for missing in missing_value_types]
+            # Todo: include row and column number
+            for missing in missing_value_types:
+                self.issue_list.append(
+                    ResourceNotDefinedError[ClassEntity](
+                        resource_type="class",
+                        identifier=cast(ClassEntity, missing),
+                        location="Classes sheet",
+                    )
                 )
-            )
 
         # USE CASE: models are extended (user + last = complete)
         if self.metadata.schema_ == SchemaCompleteness.extended:
             defined_classes |= {class_.class_ for class_ in cast(InformationRules, self.rules.last).classes}
             if missing_value_types := referred_object_types.difference(defined_classes):
-                self.issue_list.append(
-                    issues.spreadsheet.ValueTypeNotDefinedError(
-                        [cast(ClassEntity, missing).versioned_id for missing in missing_value_types]
+                # Todo: include row and column number
+                for missing in missing_value_types:
+                    self.issue_list.append(
+                        ResourceNotDefinedError(
+                            resource_type="class",
+                            identifier=cast(ClassEntity, missing),
+                            location="Classes sheet",
+                        )
                     )
-                )
 
     def _class_parent_pairs(self) -> dict[ClassEntity, list[ClassEntity]]:
         class_subclass_pairs: dict[ClassEntity, list[ClassEntity]] = {}
@@ -173,7 +193,10 @@ class InformationPostValidation:
             reused_namespaces = [value for value, count in Counter(prefixes.values()).items() if count > 1]
             impacted_prefixes = [key for key, value in prefixes.items() if value in reused_namespaces]
             self.issue_list.append(
-                issues.spreadsheet.PrefixNamespaceCollisionError(
-                    prefixes=impacted_prefixes, namespaces=reused_namespaces
+                NeatValueError(
+                    "Namespace collision detected. The following prefixes "
+                    f"are assigned to the same namespace: {impacted_prefixes}"
+                    f"\nImpacted namespaces: {reused_namespaces}"
+                    "\nMake sure that each unique namespace is assigned to a unique prefix"
                 )
             )

cognite/neat/rules/transformers/_base.py

@@ -0,0 +1,15 @@
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar
+
+from cognite.neat.rules._shared import Rules
+
+T_RulesIn = TypeVar("T_RulesIn", bound=Rules)
+T_RulesOut = TypeVar("T_RulesOut", bound=Rules)
+
+
+class RulesTransformer(ABC, Generic[T_RulesIn, T_RulesOut]):
+    """This is the base class for all rule transformers."""
+
+    @abstractmethod
+    def transform(self, rules: T_RulesIn) -> T_RulesOut:
+        raise NotImplementedError()

cognite/neat/utils/auxiliary.py

@@ -3,15 +3,14 @@ import importlib
 import inspect
 import logging
 import time
-from collections.abc import Callable, Iterable
+from collections.abc import Callable
 from datetime import datetime
 from functools import wraps
 from types import ModuleType
 
 from cognite.client.exceptions import CogniteDuplicatedError, CogniteReadTimeout
-from pydantic_core import ErrorDetails
 
-from cognite.neat.exceptions import NeatImportError
+from cognite.neat.issues.errors import NeatImportError
 
 
 def local_import(module: str, extra: str) -> ModuleType:
@@ -119,38 +118,6 @@ def create_sha256_hash(string: str) -> str:
     return hash_value
 
 
-# Will likely be removed with legacy code
-def generate_exception_report(exceptions: list[dict] | list[ErrorDetails] | None, category: str = "") -> str:
-    exceptions_as_dict = _order_expectations_by_type(exceptions) if exceptions else {}
-    report = ""
-
-    for exception_type in exceptions_as_dict.keys():
-        title = f"# {category}: {exception_type}" if category else ""
-        warnings = "\n- " + "\n- ".join(exceptions_as_dict[exception_type])
-        report += title + warnings + "\n\n"
-
-    return report
-
-
-def _order_expectations_by_type(
-    exceptions: list[dict] | list[ErrorDetails],
-) -> dict[str, list[str]]:
-    exception_dict: dict[str, list[str]] = {}
-    for exception in exceptions:
-        if not isinstance(exception["loc"], str) and isinstance(exception["loc"], Iterable):
-            location = f"[{'/'.join(str(e) for e in exception['loc'])}]"
-        else:
-            location = ""
-
-        issue = f"{exception['msg']} {location}"
-
-        if exception_dict.get(exception["type"]) is None:
-            exception_dict[exception["type"]] = [issue]
-        else:
-            exception_dict[exception["type"]].append(issue)
-    return exception_dict
-
-
 def string_to_ideal_type(input_string: str) -> int | bool | float | datetime | str:
     try:
         # Try converting to int

cognite/neat/utils/text.py

@@ -1,4 +1,6 @@
 import re
+from collections.abc import Collection
+from typing import Any
 
 
 def to_camel(string: str) -> str:
@@ -106,3 +108,18 @@ def to_snake(string: str) -> str:
 
 def replace_non_alphanumeric_with_underscore(text: str) -> str:
     return re.sub(r"\W+", "_", text)
+
+
+def humanize_collection(collection: Collection[Any], /, *, sort: bool = True) -> str:
+    if not collection:
+        return ""
+    elif len(collection) == 1:
+        return str(next(iter(collection)))
+
+    strings = (str(item) for item in collection)
+    if sort:
+        sequence = sorted(strings)
+    else:
+        sequence = list(strings)
+
+    return f"{', '.join(sequence[:-1])} and {sequence[-1]}"

cognite/neat/workflows/base.py

@@ -13,9 +13,9 @@ from prometheus_client import Gauge
 
 from cognite.neat.app.monitoring.metrics import NeatMetricsCollector
 from cognite.neat.config import Config
+from cognite.neat.issues.errors import WorkflowConfigurationNotSetError, WorkflowStepOutputError
 from cognite.neat.utils.auxiliary import retry_decorator
 from cognite.neat.workflows import cdf_store, utils
-from cognite.neat.workflows._exceptions import ConfigurationNotSet, InvalidStepOutputException
 from cognite.neat.workflows.cdf_store import CdfStore
 from cognite.neat.workflows.model import (
     FlowMessage,
@@ -316,7 +316,7 @@ class BaseWorkflow:
                         elif isinstance(out_obj, DataContract):
                             self.data[type(out_obj).__name__] = out_obj
                         else:
-                            raise InvalidStepOutputException(step_type=type(out_obj).__name__)
+                            raise WorkflowStepOutputError(step_type=type(out_obj).__name__)
 
             elif step.stype == StepType.START_WORKFLOW_TASK_STEP:
                 if self.task_builder:
@@ -510,7 +510,7 @@ class BaseWorkflow:
         if storage_type == "transformation_rules":
             self.rules_storage_path = Path(storage_path)
             if self.default_dataset_id is None:
-                raise ConfigurationNotSet("default_dataset_id")
+                raise WorkflowConfigurationNotSetError("default_dataset_id")
             self.cdf_store = cdf_store.CdfStore(
                 self.cdf_client, data_set_id=self.default_dataset_id, rules_storage_path=self.rules_storage_path
             )
@@ -576,7 +576,7 @@ class BaseWorkflow:
 
         file_list: list[Path] = []
         if self.data_store_path is None:
-            raise ConfigurationNotSet("data_store_path")
+            raise WorkflowConfigurationNotSetError("data_store_path")
         workflow_data_path = Path(self.data_store_path) / "workflows" / self.name
         try:
             for root, _dirs, files in os.walk(workflow_data_path):

cognite/neat/workflows/cdf_store.py

@@ -11,7 +11,7 @@ from cognite.client.data_classes import Event, FileMetadataUpdate
 from fastapi.encoders import jsonable_encoder
 from pydantic import BaseModel
 
-from cognite.neat.workflows._exceptions import ConfigurationNotSet
+from cognite.neat.issues.errors import WorkflowConfigurationNotSetError
 from cognite.neat.workflows.model import WorkflowFullStateReport, WorkflowState, WorkflowStepEvent
 from cognite.neat.workflows.utils import get_file_hash
 
@@ -53,7 +53,7 @@ class CdfStore:
     def package_workflow(self, workflow_name: str) -> str:
         """Creates a zip archive from a folder"""
         if self.workflows_storage_path is None:
-            raise ConfigurationNotSet("workflows_storage_path")
+            raise WorkflowConfigurationNotSetError("workflows_storage_path")
         folder_path = self.workflows_storage_path / workflow_name
         archive_path = self.workflows_storage_path / f"{workflow_name}.zip"
         # Make sure the folder exists
@@ -77,7 +77,7 @@ class CdfStore:
         # Make sure the archive exists
         workflow_name = workflow_name.replace(".zip", "")
         if self.workflows_storage_path is None:
-            raise ConfigurationNotSet("workflows_storage_path")
+            raise WorkflowConfigurationNotSetError("workflows_storage_path")
         package_full_path = Path(self.workflows_storage_path) / f"{workflow_name}.zip"
         output_folder = Path(self.workflows_storage_path) / workflow_name
         if not package_full_path.is_file():

cognite/neat/workflows/steps/data_contracts.py

@@ -9,13 +9,13 @@ from cognite.client.data_classes import (
 )
 from cognite.client.data_classes.data_modeling import EdgeApply, NodeApply
 
-from cognite.neat.graph.stores import NeatGraphStore
 from cognite.neat.rules.models import (
     AssetRules,
     DMSRules,
     DomainRules,
     InformationRules,
 )
+from cognite.neat.store import NeatGraphStore
 from cognite.neat.workflows.steps.step_model import DataContract
 
 

cognite/neat/workflows/steps/lib/current/graph_extractor.py

@@ -8,8 +8,8 @@ from rdflib import URIRef
 from cognite.neat.constants import DEFAULT_NAMESPACE
 from cognite.neat.graph.extractors import RdfFileExtractor
 from cognite.neat.graph.extractors._mock_graph_generator import MockGraphGenerator
+from cognite.neat.issues.errors import WorkflowStepNotInitializedError
 from cognite.neat.rules._shared import DMSRules, InformationRules
-from cognite.neat.workflows._exceptions import StepNotInitialized
 from cognite.neat.workflows.model import FlowMessage, StepExecutionStatus
 from cognite.neat.workflows.steps.data_contracts import MultiRuleData, NeatGraph
 from cognite.neat.workflows.steps.step_model import Configurable, Step
@@ -45,7 +45,7 @@ class GraphFromMockData(Step):
         self, rules: MultiRuleData, graph_store: NeatGraph
     ) -> FlowMessage:
         if self.configs is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         if not rules.information and not rules.dms:
             return FlowMessage(
@@ -110,7 +110,7 @@ class GraphFromRdfFile(Step):
 
     def run(self, graph_store: NeatGraph) -> FlowMessage:  # type: ignore[override, syntax]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         if source_file := self.configs["File path"]:
             NeatGraph.graph.write(

cognite/neat/workflows/steps/lib/current/graph_loader.py

@@ -2,7 +2,7 @@ import time
 from pathlib import Path
 from typing import ClassVar
 
-from cognite.neat.workflows._exceptions import StepNotInitialized
+from cognite.neat.issues.errors import WorkflowStepNotInitializedError
 from cognite.neat.workflows.model import FlowMessage
 from cognite.neat.workflows.steps.data_contracts import NeatGraph
 from cognite.neat.workflows.steps.step_model import Configurable, Step
@@ -34,7 +34,7 @@ class GraphToRdfFile(Step):
         self, graph: NeatGraph
     ) -> FlowMessage:  # type: ignore[syntax]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         storage_path = self.data_store_path / Path(self.configs["File path"])
         relative_graph_file_path = str(storage_path).split("/data/")[1]

cognite/neat/workflows/steps/lib/current/graph_store.py

@@ -1,6 +1,6 @@
 from typing import ClassVar
 
-from cognite.neat.graph.stores import NeatGraphStore
+from cognite.neat.store import NeatGraphStore
 from cognite.neat.workflows.model import FlowMessage
 from cognite.neat.workflows.steps.data_contracts import (
     MultiRuleData,

cognite/neat/workflows/steps/lib/current/rules_exporter.py

@@ -2,10 +2,10 @@ import time
 from pathlib import Path
 from typing import ClassVar, Literal, cast
 
+from cognite.neat.issues.errors import WorkflowStepNotInitializedError
 from cognite.neat.rules import exporters
-from cognite.neat.rules._shared import DMSRules, InformationRules, Rules
+from cognite.neat.rules._shared import DMSRules, InformationRules, VerifiedRules
 from cognite.neat.rules.models import RoleTypes
-from cognite.neat.workflows._exceptions import StepNotInitialized
 from cognite.neat.workflows.model import FlowMessage, StepExecutionStatus
 from cognite.neat.workflows.steps.data_contracts import CogniteClient, MultiRuleData
 from cognite.neat.workflows.steps.step_model import Configurable, Step
@@ -61,7 +61,7 @@ class DeleteDataModelFromCDF(Step):
 
     def run(self, rules: MultiRuleData, cdf_client: CogniteClient) -> FlowMessage:  # type: ignore[override]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
         components_to_delete = {
             cast(Literal["all", "spaces", "data_models", "views", "containers"], key)
             for key, value in self.complex_configs["Components"].items()
@@ -168,7 +168,7 @@ class RulesToDMS(Step):
 
     def run(self, rules: MultiRuleData, cdf_client: CogniteClient) -> FlowMessage:  # type: ignore[override]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
         existing_components_handling = cast(
             Literal["fail", "update", "skip", "force"], self.configs["Existing component handling"]
         )
@@ -291,7 +291,7 @@ class RulesToExcel(Step):
 
     def run(self, rules: MultiRuleData) -> FlowMessage:  # type: ignore[override, syntax]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         dump_format = self.configs.get("Dump Format", "user")
         styling = cast(exporters.ExcelExporter.Style, self.configs.get("Styling", "default"))
@@ -317,7 +317,7 @@ class RulesToExcel(Step):
             new_model_id=new_model_id,
         )
 
-        rule_instance: Rules
+        rule_instance: VerifiedRules
         if rules.domain:
             rule_instance = rules.domain
         elif rules.information:
@@ -369,7 +369,7 @@ class RulesToOntology(Step):
 
     def run(self, rules: MultiRuleData) -> FlowMessage:  # type: ignore[override, syntax]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         if not rules.information and not rules.dms:
             return FlowMessage(
@@ -420,7 +420,7 @@ class RulesToSHACL(Step):
 
     def run(self, rules: MultiRuleData) -> FlowMessage:  # type: ignore[override, syntax]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         if not rules.information and not rules.dms:
             return FlowMessage(
@@ -471,7 +471,7 @@ class RulesToSemanticDataModel(Step):
 
     def run(self, rules: MultiRuleData) -> FlowMessage:  # type: ignore[override, syntax]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         if not rules.information and not rules.dms:
             return FlowMessage(
@@ -525,7 +525,7 @@ class RulesToCDFTransformations(Step):
 
     def run(self, rules: MultiRuleData, cdf_client: CogniteClient) -> FlowMessage:  # type: ignore[override]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         input_rules = rules.dms or rules.information
         if input_rules is None:

cognite/neat/workflows/steps/lib/current/rules_importer.py

@@ -5,11 +5,11 @@ from typing import ClassVar
 from cognite.client import CogniteClient
 from cognite.client.data_classes.data_modeling import DataModelId
 
+from cognite.neat.issues.errors import WorkflowStepNotInitializedError
 from cognite.neat.issues.formatters import FORMATTER_BY_NAME
 from cognite.neat.rules import importers
 from cognite.neat.rules.models import RoleTypes
 from cognite.neat.rules.models.entities import DataModelEntity, DMSUnknownEntity
-from cognite.neat.workflows._exceptions import StepNotInitialized
 from cognite.neat.workflows.model import FlowMessage, StepExecutionStatus
 from cognite.neat.workflows.steps.data_contracts import MultiRuleData
 from cognite.neat.workflows.steps.step_model import Configurable, Step
@@ -55,7 +55,7 @@ class ExcelToRules(Step):
 
     def run(self, flow_message: FlowMessage) -> (FlowMessage, MultiRuleData):  # type: ignore[syntax, override]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         file_name = self.configs.get("File name", None)
         full_path = flow_message.payload.get("full_path", None) if flow_message.payload else None
@@ -124,7 +124,7 @@ class OntologyToRules(Step):
 
     def run(self, flow_message: FlowMessage) -> (FlowMessage, MultiRuleData):  # type: ignore[syntax, override]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         file_name = self.configs.get("File name", None)
         full_path = flow_message.payload.get("full_path", None) if flow_message.payload else None
@@ -193,7 +193,7 @@ class IMFToRules(Step):
 
     def run(self, flow_message: FlowMessage) -> (FlowMessage, MultiRuleData):  # type: ignore[syntax, override]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         file_name = self.configs.get("File name", None)
 
@@ -271,7 +271,7 @@ class DMSToRules(Step):
 
     def run(self, cdf_client: CogniteClient) -> (FlowMessage, MultiRuleData):  # type: ignore[syntax, override]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         datamodel_id_str = self.configs.get("Data model id")
         if datamodel_id_str is None:
@@ -360,7 +360,7 @@ class RulesInferenceFromRdfFile(Step):
 
     def run(self, flow_message: FlowMessage) -> (FlowMessage, MultiRuleData):  # type: ignore[syntax, override]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         file_path = self.configs.get("File path", None)
         full_path = flow_message.payload.get("full_path", None) if flow_message.payload else None

cognite/neat/workflows/steps/lib/current/rules_validator.py

@@ -6,11 +6,10 @@ from typing import ClassVar
 from cognite.client import CogniteClient
 
 from cognite.neat.issues import NeatIssueList
-from cognite.neat.issues.errors.resources import ReferredResourceNotFoundError
+from cognite.neat.issues.errors import ResourceNotFoundError, WorkflowStepNotInitializedError
 from cognite.neat.issues.formatters import FORMATTER_BY_NAME
 from cognite.neat.rules.models import DMSRules, SchemaCompleteness
 from cognite.neat.utils.cdf.loaders import ViewLoader
-from cognite.neat.workflows._exceptions import StepNotInitialized
 from cognite.neat.workflows.model import FlowMessage, StepExecutionStatus
 from cognite.neat.workflows.steps.data_contracts import MultiRuleData
 from cognite.neat.workflows.steps.step_model import Configurable, Step
@@ -42,7 +41,7 @@ class ValidateRulesAgainstCDF(Step):
 
     def run(self, rules: MultiRuleData, cdf_client: CogniteClient) -> FlowMessage:  # type: ignore[override, syntax]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         if not isinstance(rules.dms, DMSRules):
             return FlowMessage(
@@ -64,17 +63,17 @@ class ValidateRulesAgainstCDF(Step):
         missing_spaces = [
             error.identifier
             for error in errors
-            if isinstance(error, ReferredResourceNotFoundError) and error.resource_type == "Space"
+            if isinstance(error, ResourceNotFoundError) and error.resource_type == "Space"
         ]
         missing_views = [
             error.identifier
             for error in errors
-            if isinstance(error, ReferredResourceNotFoundError) and error.resource_type == "View"
+            if isinstance(error, ResourceNotFoundError) and error.resource_type == "View"
         ]
         missing_containers = [
             error.identifier
             for error in errors
-            if isinstance(error, ReferredResourceNotFoundError) and error.resource_type == "Container"
+            if isinstance(error, ResourceNotFoundError) and error.resource_type == "Container"
         ]
 
         retrieved_spaces = cdf_client.data_modeling.spaces.retrieve(missing_spaces).as_write()

cognite/neat/workflows/steps/lib/io/io_steps.py

@@ -6,7 +6,7 @@ from typing import ClassVar
 import requests
 from cognite.client import CogniteClient
 
-from cognite.neat.workflows._exceptions import StepNotInitialized
+from cognite.neat.issues.errors import WorkflowStepNotInitializedError
 from cognite.neat.workflows.model import FlowMessage, StepExecutionStatus
 from cognite.neat.workflows.steps.step_model import Configurable, Step
 
@@ -51,7 +51,7 @@ class DownloadFileFromGitHub(Step):
 
     def run(self) -> FlowMessage:  # type: ignore[override, syntax]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
         github_filepath = self.configs["github.filepath"]
         github_personal_token = self.configs["github.personal_token"]
         github_owner = self.configs["github.owner"]
@@ -136,7 +136,7 @@ class UploadFileToGitHub(Step):
 
     def run(self) -> FlowMessage:  # type: ignore[override, syntax]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
         github_filepath = self.configs["github.filepath"]
         github_personal_token = self.configs["github.personal_token"]
         github_owner = self.configs["github.owner"]
@@ -210,7 +210,7 @@ class DownloadFileFromCDF(Step):
 
     def run(self, cdf_client: CogniteClient) -> FlowMessage:  # type: ignore[override, syntax]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
 
         output_dir = self.data_store_path / Path(self.configs["local.storage_dir"])
         output_dir.mkdir(parents=True, exist_ok=True)
@@ -244,7 +244,7 @@ class UploadFileToCDF(Step):
 
     def run(self, cdf_client: CogniteClient) -> FlowMessage:  # type: ignore[override, syntax]
         if self.configs is None or self.data_store_path is None:
-            raise StepNotInitialized(type(self).__name__)
+            raise WorkflowStepNotInitializedError(type(self).__name__)
         full_local_file_path = (
             self.data_store_path / Path(self.configs["local.storage_dir"]) / self.configs["local.file_name"]
         )

cognite/neat/workflows/steps_registry.py

@@ -14,8 +14,7 @@ import cognite.neat.workflows.steps.lib.current
 import cognite.neat.workflows.steps.lib.io
 from cognite.neat.app.monitoring.metrics import NeatMetricsCollector
 from cognite.neat.config import Config
-from cognite.neat.exceptions import InvalidWorkFlowError
-from cognite.neat.workflows._exceptions import ConfigurationNotSet
+from cognite.neat.issues.errors import WorkflowConfigurationNotSetError, WorkFlowMissingDataError
 from cognite.neat.workflows.model import FlowMessage, WorkflowConfigs
 from cognite.neat.workflows.steps.step_model import Configurable, DataContract, Step
 
@@ -71,7 +70,7 @@ class StepsRegistry:
 
     def load_workflow_step_classes(self, workflow_name: str):
         if not self.data_store_path:
-            raise ConfigurationNotSet("data_store_path")
+            raise WorkflowConfigurationNotSetError("data_store_path")
         workflow_steps_path = Path(self.data_store_path) / "workflows" / workflow_name
         if workflow_steps_path.exists():
             self.load_custom_step_classes(workflow_steps_path, scope="workflow")
@@ -164,9 +163,9 @@ class StepsRegistry:
                         missing_data.append(parameter.annotation.__name__)
                         continue
                 if not is_valid:
-                    raise InvalidWorkFlowError(step_name, missing_data)
+                    raise WorkFlowMissingDataError(step_name, frozenset(missing_data))
                 return step_obj.run(*input_data)
-        raise InvalidWorkFlowError(step_name, [])
+        raise WorkFlowMissingDataError(step_name, frozenset({}))
 
     def get_list_of_steps(self) -> list[StepMetadata]:
         steps: list[StepMetadata] = []

{cognite_neat-0.88.2.dist-info → cognite_neat-0.88.3.dist-info}/METADATA

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