cognite-neat 0.75.7__py3-none-any.whl → 0.75.9__py3-none-any.whl

cognite/neat/rules/models/rules/_types/_field.py

@@ -19,23 +19,11 @@ from pydantic_core import PydanticCustomError
 from cognite.neat.rules import exceptions
 
 from ._base import (
-    CLASS_ID_COMPLIANCE_REGEX,
-    ENTITY_ID_REGEX_COMPILED,
     MORE_THAN_ONE_NONE_ALPHANUMERIC_REGEX,
     PREFIX_COMPLIANCE_REGEX,
     PROPERTY_ID_COMPLIANCE_REGEX,
     VERSION_COMPLIANCE_REGEX,
-    VERSIONED_ENTITY_REGEX_COMPILED,
-    ClassEntity,
-    ContainerEntity,
-    ParentClassEntity,
-    ReferenceEntity,
-    Undefined,
-    Unknown,
-    ViewEntity,
-    ViewPropEntity,
 )
-from ._value import DMS_VALUE_TYPE_MAPPINGS, XSD_VALUE_TYPE_MAPPINGS, DMSValueType, XSDValueType
 
 
 def _custom_error(exc_factory: Callable[[str | None, Exception], Any]) -> Any:
@@ -52,39 +40,6 @@ def _raise(exception: PydanticCustomError):
     raise exception
 
 
-def _split_parent(value: str | list[ParentClassEntity]) -> list[ParentClassEntity] | None:
-    if isinstance(value, list) and all(isinstance(x, ParentClassEntity) for x in value):
-        return value
-
-    if not (isinstance(value, str) and value):
-        return None
-
-    parents = []
-    for v in value.replace(", ", ",").split(","):
-        if ENTITY_ID_REGEX_COMPILED.match(v) or VERSIONED_ENTITY_REGEX_COMPILED.match(v):
-            parents.append(ParentClassEntity.from_string(entity_string=v))
-        else:
-            parents.append(ParentClassEntity(prefix=Undefined, suffix=v, name=v))
-
-    return parents
-
-
-def _check_parent(value: list[ParentClassEntity]) -> list[ParentClassEntity]:
-    if not value:
-        return value
-    if illegal_ids := [v for v in value if re.search(MORE_THAN_ONE_NONE_ALPHANUMERIC_REGEX, v.suffix)]:
-        raise exceptions.MoreThanOneNonAlphanumericCharacter(
-            "parent", ", ".join(cast(list[str], illegal_ids))
-        ).to_pydantic_custom_error()
-    if illegal_ids := [v for v in value if not re.match(CLASS_ID_COMPLIANCE_REGEX, v.suffix)]:
-        for v in illegal_ids:
-            print(v.id)
-        raise exceptions.ClassSheetParentClassIDRegexViolation(
-            cast(list[str], illegal_ids), CLASS_ID_COMPLIANCE_REGEX
-        ).to_pydantic_custom_error()
-    return value
-
-
 StrOrListType = Annotated[
     str | list[str],
     BeforeValidator(lambda value: value.replace(", ", ",").split(",") if isinstance(value, str) and value else value),
@@ -141,43 +96,6 @@ VersionType = Annotated[
 ]
 
 
-ParentClassType = Annotated[
-    list[ParentClassEntity] | None,
-    BeforeValidator(_split_parent),
-    AfterValidator(_check_parent),
-    PlainSerializer(
-        lambda v: ",".join([entry.versioned_id for entry in v]) if v else None,
-        return_type=str,
-        when_used="unless-none",
-    ),
-]
-
-ClassType = Annotated[
-    ClassEntity,
-    BeforeValidator(lambda value: (ClassType.from_raw(value) if isinstance(value, str) else value)),
-    AfterValidator(
-        lambda value: (
-            _raise(exceptions.MoreThanOneNonAlphanumericCharacter("class_", value.suffix).to_pydantic_custom_error())
-            if re.search(MORE_THAN_ONE_NONE_ALPHANUMERIC_REGEX, value.suffix)
-            else (
-                value
-                if re.match(CLASS_ID_COMPLIANCE_REGEX, value.suffix)
-                else _raise(
-                    exceptions.ClassSheetClassIDRegexViolation(
-                        value.suffix, CLASS_ID_COMPLIANCE_REGEX
-                    ).to_pydantic_custom_error()
-                )
-            )
-        )
-    ),
-    PlainSerializer(
-        lambda v: v.versioned_id,
-        return_type=str,
-        when_used="unless-none",
-    ),
-]
-
-
 PropertyType = Annotated[
     str,
     AfterValidator(
@@ -194,146 +112,3 @@ PropertyType = Annotated[
         )
     ),
 ]
-
-
-def _reference_entity_type_before_validator(value: Any | None = None) -> Any:
-    if not value:
-        return None
-    elif isinstance(value, rdflib.URIRef | ReferenceEntity):
-        return value
-    elif ReferenceEntity.from_raw(value).prefix == Undefined:
-        # case1: then this must be a URIRef!
-        return rdflib.URIRef(str(TypeAdapter(HttpUrl).validate_python(value)))
-    else:
-        # case2: this is a ReferenceEntity
-        return ReferenceEntity.from_raw(value)
-
-
-ReferenceType = Annotated[
-    ReferenceEntity | rdflib.URIRef | None,
-    BeforeValidator(_reference_entity_type_before_validator),
-    PlainSerializer(
-        lambda v: v.versioned_id if isinstance(v, ReferenceEntity) else str(v),
-        return_type=str,
-        when_used="unless-none",
-    ),
-]
-
-
-ContainerType = Annotated[
-    ContainerEntity,
-    BeforeValidator(ContainerEntity.from_raw),
-    PlainSerializer(
-        lambda v: v.versioned_id,
-        return_type=str,
-        when_used="unless-none",
-    ),
-]
-
-
-ViewType = Annotated[
-    ViewEntity,
-    BeforeValidator(ViewEntity.from_raw),
-    PlainSerializer(
-        lambda v: v.versioned_id,
-        return_type=str,
-        when_used="unless-none",
-    ),
-]
-
-
-def _semantic_value_type_before_validator(value: Any) -> Any:
-    if isinstance(value, XSDValueType | ClassEntity) or not isinstance(value, str):
-        return value
-    elif value in XSD_VALUE_TYPE_MAPPINGS:
-        return XSD_VALUE_TYPE_MAPPINGS[value]
-    elif value.lower() in XSD_VALUE_TYPE_MAPPINGS:
-        return XSD_VALUE_TYPE_MAPPINGS[value.lower()]
-    elif value == "#N/A":
-        return ClassEntity(prefix=Undefined, suffix=Unknown)
-    else:
-        return ClassEntity.from_raw(value)
-
-
-def _semantic_value_type_serializer(value: Any) -> str:
-    if isinstance(value, ClassEntity):
-        return value.versioned_id
-    elif isinstance(value, XSDValueType):
-        return value.suffix
-    else:
-        return str(value)
-
-
-def _dms_value_type_before_validator(value: Any) -> Any:
-    if isinstance(value, DMSValueType | ViewPropEntity) or not isinstance(value, str):
-        return value
-    elif value in DMS_VALUE_TYPE_MAPPINGS:
-        return DMS_VALUE_TYPE_MAPPINGS[value]
-    elif value.lower() in DMS_VALUE_TYPE_MAPPINGS:
-        return DMS_VALUE_TYPE_MAPPINGS[value.lower()]
-    else:
-        return ViewPropEntity.from_raw(value)
-
-
-SemanticValueType = Annotated[
-    XSDValueType | ClassEntity,
-    BeforeValidator(_semantic_value_type_before_validator),
-    PlainSerializer(
-        _semantic_value_type_serializer,
-        return_type=str,
-        when_used="unless-none",
-    ),
-]
-
-CdfValueType = Annotated[
-    DMSValueType | ViewPropEntity,
-    BeforeValidator(_dms_value_type_before_validator),
-    PlainSerializer(
-        lambda v: v.versioned_id if isinstance(v, ViewPropEntity | ViewEntity) else v.dms()._type,
-        return_type=str,
-        when_used="unless-none",
-    ),
-]
-
-
-def _from_str_or_list_container(value: Any) -> list[ContainerEntity] | Any:
-    if not value:
-        return value
-    if isinstance(value, str):
-        return [ContainerEntity.from_raw(entry.strip()) for entry in value.split(",")]
-    elif isinstance(value, list):
-        return [ContainerEntity.from_raw(entry.strip()) if isinstance(entry, str) else entry for entry in value]
-    else:
-        return value
-
-
-def _from_str_or_list_view(value: Any) -> list[ViewEntity] | Any:
-    if not value:
-        return value
-    if isinstance(value, str):
-        return [ViewEntity.from_raw(entry.strip()) for entry in value.split(",")]
-    elif isinstance(value, list):
-        return [ViewEntity.from_raw(entry.strip()) if isinstance(entry, str) else entry for entry in value]
-    else:
-        return value
-
-
-ContainerListType = Annotated[
-    list[ContainerEntity],
-    BeforeValidator(_from_str_or_list_container),
-    PlainSerializer(
-        lambda v: ",".join([entry.versioned_id for entry in v]),
-        return_type=str,
-        when_used="unless-none",
-    ),
-]
-
-ViewListType = Annotated[
-    list[ViewEntity],
-    BeforeValidator(_from_str_or_list_view),
-    PlainSerializer(
-        lambda v: ",".join([entry.versioned_id for entry in v]),
-        return_type=str,
-        when_used="unless-none",
-    ),
-]

cognite/neat/utils/cdf_loaders/_data_modeling.py

@@ -60,7 +60,9 @@ class DataModelingLoader(
         except CogniteAPIError as e:
             failed_items = {failed.as_id() for failed in e.failed if hasattr(failed, "as_id")}
             to_redeploy = [
-                item for item in items if item.as_id() in failed_items and item.as_id() not in tried_force_deploy  # type: ignore[attr-defined]
+                item
+                for item in items
+                if item.as_id() in failed_items and item.as_id() not in tried_force_deploy  # type: ignore[attr-defined]
             ]
             if not to_redeploy:
                 # Avoid infinite loop

cognite/neat/utils/cdf_loaders/_ingestion.py

@@ -81,12 +81,10 @@ class RawTableLoader(ResourceLoader[RawTableID, RawTableWrite, RawTable, RawTabl
         return item.as_id()
 
     @overload
-    def _groupby_database(self, items: Sequence[RawTableWrite]) -> Iterable[tuple[str, Iterable[RawTableWrite]]]:
-        ...
+    def _groupby_database(self, items: Sequence[RawTableWrite]) -> Iterable[tuple[str, Iterable[RawTableWrite]]]: ...
 
     @overload
-    def _groupby_database(self, items: SequenceNotStr[RawTableID]) -> Iterable[tuple[str, Iterable[RawTableID]]]:
-        ...
+    def _groupby_database(self, items: SequenceNotStr[RawTableID]) -> Iterable[tuple[str, Iterable[RawTableID]]]: ...
 
     def _groupby_database(
         self, items: Sequence[RawTableWrite] | SequenceNotStr[RawTableID]

cognite/neat/utils/spreadsheet.py

@@ -37,8 +37,7 @@ def read_individual_sheet(
     sheet_name: str,
     return_read_info: Literal[True],
     expected_headers: list[str] | None = None,
-) -> tuple[list[dict], SpreadsheetRead]:
-    ...
+) -> tuple[list[dict], SpreadsheetRead]: ...
 
 
 @overload
@@ -47,8 +46,7 @@ def read_individual_sheet(
     sheet_name: str,
     return_read_info: Literal[False] = False,
     expected_headers: list[str] | None = None,
-) -> list[dict]:
-    ...
+) -> list[dict]: ...
 
 
 def read_individual_sheet(

cognite/neat/utils/utils.py

@@ -74,13 +74,11 @@ def _get_cognite_client(config: CogniteClientConfig, credentials: CredentialProv
 
 
 @overload
-def remove_namespace(*URI: URIRef | str, special_separator: str = "#_") -> str:
-    ...
+def remove_namespace(*URI: URIRef | str, special_separator: str = "#_") -> str: ...
 
 
 @overload
-def remove_namespace(*URI: tuple[URIRef | str, ...], special_separator: str = "#_") -> tuple[str, ...]:
-    ...
+def remove_namespace(*URI: tuple[URIRef | str, ...], special_separator: str = "#_") -> tuple[str, ...]: ...
 
 
 def remove_namespace(

cognite/neat/workflows/base.py

@@ -11,8 +11,8 @@ import yaml
 from cognite.client import ClientConfig, CogniteClient
 from prometheus_client import Gauge
 
-from cognite.neat.app.api.configuration import Config
 from cognite.neat.app.monitoring.metrics import NeatMetricsCollector
+from cognite.neat.config import Config
 from cognite.neat.utils.utils import retry_decorator
 from cognite.neat.workflows import cdf_store, utils
 from cognite.neat.workflows._exceptions import ConfigurationNotSet, InvalidStepOutputException
@@ -45,7 +45,7 @@ class BaseWorkflow:
         self,
         name: str,
         client: CogniteClient,
-        steps_registry: StepsRegistry | None = None,
+        steps_registry: StepsRegistry,
         workflow_steps: list[WorkflowStepDefinition] | None = None,
         default_dataset_id: int | None = None,
     ):
@@ -81,7 +81,7 @@ class BaseWorkflow:
         self.auto_workflow_cleanup = False
         self.step_classes = None
         self.data: dict[str, DataContract | FlowMessage | CdfStore | CogniteClient | None] = {}
-        self.steps_registry: StepsRegistry = steps_registry or StepsRegistry()
+        self.steps_registry: StepsRegistry = steps_registry
 
     def start(self, sync=False, is_ephemeral=False, **kwargs) -> FlowMessage | None:
         """Starts workflow execution.sync=True will block until workflow is completed and
@@ -223,7 +223,7 @@ class BaseWorkflow:
 
     def copy(self) -> "BaseWorkflow":
         """Create a copy of the workflow"""
-        new_instance = self.__class__(self.name, self.cdf_client)
+        new_instance = self.__class__(self.name, self.cdf_client, self.steps_registry)
         new_instance.workflow_steps = self.workflow_steps
         new_instance.configs = self.configs
         new_instance.set_task_builder(self.task_builder)
@@ -345,7 +345,7 @@ class BaseWorkflow:
                     raise Exception(f"Workflow {self.name} is not running , step {step_name} is skipped")
                 self.state = WorkflowState.RUNNING_WAITING
                 timeout = 3000000.0
-                if "wait_timeout" in step.params and step.params["wait_timeout"]:
+                if step.params.get("wait_timeout"):
                     timeout = float(step.params["wait_timeout"])
                 # reporting workflow execution before waiting for event
                 logging.info(f"Workflow {self.name} is waiting for event")

cognite/neat/workflows/manager.py

@@ -4,15 +4,15 @@ import shutil
 import sys
 import time
 import traceback
-from pathlib import Path
 
 from cognite.client import CogniteClient
 from prometheus_client import Gauge
 from pydantic import BaseModel
 
+from cognite.neat.config import Config
 from cognite.neat.workflows import BaseWorkflow
 from cognite.neat.workflows.base import WorkflowDefinition
-from cognite.neat.workflows.model import FlowMessage, InstanceStartMethod, WorkflowState
+from cognite.neat.workflows.model import FlowMessage, InstanceStartMethod, WorkflowState, WorkflowStepDefinition
 from cognite.neat.workflows.steps_registry import StepsRegistry
 from cognite.neat.workflows.tasks import WorkflowTaskBuilder
 
@@ -28,32 +28,21 @@ class WorkflowStartStatus(BaseModel, arbitrary_types_allowed=True):
 class WorkflowManager:
     """Workflow manager is responsible for loading, saving and managing workflows
     client: CogniteClient
-    registry_storage_type: str = "file"
-    workflows_storage_path: Path = Path("workflows")
-    rules_storage_path: Path = Path("rules")
-    data_set_id: int = None,
+    config: Config
     """
 
-    def __init__(
-        self,
-        client: CogniteClient | None = None,
-        registry_storage_type: str = "file",
-        workflows_storage_path: Path | None = None,
-        rules_storage_path: Path | None = None,
-        data_store_path: Path | None = None,
-        data_set_id: int | None = None,
-    ):
+    def __init__(self, client: CogniteClient, config: Config):
         self.client = client
-        self.data_set_id = data_set_id
-        self.data_store_path = data_store_path
+        self.data_set_id = config.cdf_default_dataset_id
+        self.data_store_path = config.data_store_path
         self.workflow_registry: dict[str, BaseWorkflow] = {}
         self.ephemeral_instance_registry: dict[str, BaseWorkflow] = {}
-        self.workflows_storage_type = registry_storage_type
-        # todo use pathlib
-        self.workflows_storage_path = workflows_storage_path if workflows_storage_path else Path("workflows")
-        self.rules_storage_path = rules_storage_path if rules_storage_path else Path("rules")
+        self.workflows_storage_type = config.workflows_store_type
+        self.config = config
+        self.workflows_storage_path = config.workflows_store_path
+        self.rules_storage_path = config.rules_store_path
         self.task_builder = WorkflowTaskBuilder(client, self)
-        self.steps_registry = StepsRegistry(self.data_store_path)
+        self.steps_registry = StepsRegistry(self.config)
         self.steps_registry.load_step_classes()
 
     def update_cdf_client(self, client: CogniteClient):
@@ -206,10 +195,21 @@ class WorkflowManager:
         self, workflow_name: str, step_id: str = "", flow_msg: FlowMessage | None = None, sync: bool | None = None
     ) -> WorkflowStartStatus:
         retrieved = self.get_workflow(workflow_name)
+
         if retrieved is None:
             return WorkflowStartStatus(
                 workflow_instance=None, is_success=False, status_text="Workflow not found in registry"
             )
+
+        if self._is_workflow_made_of_mixed_steps(retrieved.workflow_steps):
+            retrieved.state = WorkflowState.FAILED
+            return WorkflowStartStatus(
+                workflow_instance=None,
+                is_success=False,
+                status_text="Workflow consists of both legacy and current steps. "
+                "Please update the workflow to use only current steps.",
+            )
+
         workflow = retrieved
         retrieved_step = workflow.get_trigger_step(step_id)
         if retrieved_step is None:
@@ -280,3 +280,13 @@ class WorkflowManager:
         return WorkflowStartStatus(
             workflow_instance=None, is_success=False, status_text="Unsupported workflow start method"
         )
+
+    def _is_workflow_made_of_mixed_steps(self, steps: list[WorkflowStepDefinition]):
+        legacy_steps = 0
+        current_steps = 0
+        for step in steps:
+            if step.method in self.steps_registry.categorized_steps["legacy"]:
+                legacy_steps += 1
+            if step.method in self.steps_registry.categorized_steps["current"]:
+                current_steps += 1
+        return legacy_steps > 0 and current_steps > 0

cognite/neat/workflows/model.py

@@ -45,9 +45,9 @@ class FlowMessage(BaseModel):
     headers: dict[str, str] | None = None  # The headers of the message
     output_text: str | None = None  # The output text of the step that is captured in the execution log
     error_text: str | None = None  # The error text of the step that is captured in the execution log
-    next_step_ids: list[
-        str
-    ] | None = None  # If set, the workflow will skip default route and go to the next step in the list
+    next_step_ids: list[str] | None = (
+        None  # If set, the workflow will skip default route and go to the next step in the list
+    )
     step_execution_status: StepExecutionStatus = StepExecutionStatus.UNKNOWN  # The status of the step execution
 
 

cognite/neat/workflows/steps/lib/__init__.py

@@ -1,7 +0,0 @@
-from .io_steps import *  # noqa
-from .rules_importer import *  # noqa
-from .rules_validator import *  # noqa
-from .rules_exporter import *  # noqa
-from .graph_store import *  # noqa
-from .graph_loader import *  # noqa
-from .graph_extractor import *  # noqa

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

@@ -0,0 +1,6 @@
+from .rules_importer import *  # noqa
+from .rules_validator import *  # noqa
+from .rules_exporter import *  # noqa
+from .graph_store import *  # noqa
+from .graph_loader import *  # noqa
+from .graph_extractor import *  # noqa

cognite/neat/workflows/steps/lib/{rules_exporter.py → current/rules_exporter.py}

@@ -101,7 +101,7 @@ class DeleteDataModelFromCDF(Step):
         report_lines.append("\n\n# ERRORS\n\n")
         report_lines.extend(errors)
 
-        output_dir = self.data_store_path / Path("staging")
+        output_dir = self.config.staging_path
         output_dir.mkdir(parents=True, exist_ok=True)
         report_file = "dms_component_creation_report.txt"
         report_full_path = output_dir / report_file
@@ -203,7 +203,7 @@ class RulesToDMS(Step):
             existing_handling=existing_components_handling,
         )
 
-        output_dir = self.data_store_path / Path("staging")
+        output_dir = self.config.staging_path
         output_dir.mkdir(parents=True, exist_ok=True)
         file_name = (
             input_rules.metadata.external_id
@@ -223,7 +223,7 @@ class RulesToDMS(Step):
         report_lines.append("\n\n# ERRORS\n\n")
         report_lines.extend(errors)
 
-        output_dir = self.data_store_path / Path("staging")
+        output_dir = self.config.staging_path
         output_dir.mkdir(parents=True, exist_ok=True)
         report_file = "dms_component_creation_report.txt"
         report_full_path = output_dir / report_file
@@ -348,7 +348,7 @@ class RulesToOntology(Step):
                 step_execution_status=StepExecutionStatus.ABORT_AND_FAIL,
             )
 
-        default_path = self.data_store_path / "staging" / _get_default_file_name(rules, "ontology", "ttl")
+        default_path = self.config.staging_path / _get_default_file_name(rules, "ontology", "ttl")
 
         storage_path = (
             self.data_store_path / Path(self.configs["File path"]) if self.configs["File path"] else default_path
@@ -399,7 +399,7 @@ class RulesToSHACL(Step):
                 step_execution_status=StepExecutionStatus.ABORT_AND_FAIL,
             )
 
-        default_path = self.data_store_path / "staging" / _get_default_file_name(rules, "shacl", "ttl")
+        default_path = self.config.staging_path / _get_default_file_name(rules, "shacl", "ttl")
 
         storage_path = (
             self.data_store_path / Path(self.configs["File path"]) if self.configs["File path"] else default_path
@@ -450,7 +450,7 @@ class RulesToSemanticDataModel(Step):
                 step_execution_status=StepExecutionStatus.ABORT_AND_FAIL,
             )
 
-        default_path = self.data_store_path / "staging" / _get_default_file_name(rules, "semantic-data-model", "ttl")
+        default_path = self.config.staging_path / _get_default_file_name(rules, "semantic-data-model", "ttl")
 
         storage_path = (
             self.data_store_path / Path(self.configs["File path"]) if self.configs["File path"] else default_path
@@ -513,7 +513,7 @@ class RulesToCDFTransformations(Step):
         dms_exporter = exporters.DMSExporter(
             export_pipeline=True, instance_space=instance_space, export_components=["spaces"]
         )
-        output_dir = self.data_store_path / Path("staging")
+        output_dir = self.config.staging_path
         output_dir.mkdir(parents=True, exist_ok=True)
         file_name = (
             input_rules.metadata.external_id
@@ -533,7 +533,7 @@ class RulesToCDFTransformations(Step):
         report_lines.append("\n\n# ERRORS\n\n")
         report_lines.extend(errors)
 
-        output_dir = self.data_store_path / Path("staging")
+        output_dir = self.config.staging_path
         output_dir.mkdir(parents=True, exist_ok=True)
         report_file = "pipeline_creation_report.txt"
         report_full_path = output_dir / report_file

cognite/neat/workflows/steps/lib/{rules_importer.py → current/rules_importer.py}

@@ -6,8 +6,8 @@ from cognite.client import CogniteClient
 
 from cognite.neat.rules import importers
 from cognite.neat.rules.issues.formatters import FORMATTER_BY_NAME
+from cognite.neat.rules.models.entities import DataModelEntity, DMSUnknownEntity
 from cognite.neat.rules.models.rules import RoleTypes
-from cognite.neat.rules.models.rules._types import DataModelEntity, Undefined
 from cognite.neat.workflows._exceptions import StepNotInitialized
 from cognite.neat.workflows.model import FlowMessage, StepExecutionStatus
 from cognite.neat.workflows.steps.data_contracts import MultiRuleData
@@ -75,7 +75,7 @@ class ExcelToRules(Step):
         rules, issues = excel_importer.to_rules(errors="continue", role=role_enum)
 
         if rules is None:
-            output_dir = self.data_store_path / Path("staging")
+            output_dir = self.config.staging_path
             report_writer = FORMATTER_BY_NAME[self.configs["Report formatter"]]()
             report_writer.write_to_file(issues, file_or_dir_path=output_dir)
             report_file = report_writer.default_file_name
@@ -137,7 +137,7 @@ class OntologyToRules(Step):
         make_compliant = self.configs.get("Make compliant", "True") == "True"
 
         if file_name:
-            rules_file_path = Path(self.data_store_path) / "rules" / file_name
+            rules_file_path = self.config.rules_store_path / file_name
         elif full_path:
             rules_file_path = full_path
         else:
@@ -154,7 +154,7 @@ class OntologyToRules(Step):
         rules, issues = ontology_importer.to_rules(errors="continue", role=role_enum)
 
         if rules is None:
-            output_dir = self.data_store_path / Path("staging")
+            output_dir = self.config.staging_path
             report_writer = FORMATTER_BY_NAME[self.configs["Report formatter"]]()
             report_writer.write_to_file(issues, file_or_dir_path=output_dir)
             report_file = report_writer.default_file_name
@@ -207,8 +207,8 @@ class DMSToRules(Step):
             error_text = "Expected input payload to contain 'Data model id' key."
             return FlowMessage(error_text=error_text, step_execution_status=StepExecutionStatus.ABORT_AND_FAIL)
 
-        datamodel_entity = DataModelEntity.from_raw(datamodel_id_str)
-        if datamodel_entity.space is Undefined:
+        datamodel_entity = DataModelEntity.load(datamodel_id_str)
+        if isinstance(datamodel_entity, DMSUnknownEntity):
             error_text = (
                 f"Data model id should be in the format 'my_space:my_data_model(version=1)' "
                 f"or 'my_space:my_data_model', failed to parse space from {datamodel_id_str}"
@@ -226,7 +226,7 @@ class DMSToRules(Step):
         rules, issues = dms_importer.to_rules(errors="continue", role=role_enum)
 
         if rules is None:
-            output_dir = self.data_store_path / Path("staging")
+            output_dir = self.config.staging_path
             report_writer = FORMATTER_BY_NAME[self.configs["Report formatter"]]()
             report_writer.write_to_file(issues, file_or_dir_path=output_dir)
             report_file = report_writer.default_file_name

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

@@ -0,0 +1 @@
+from .io_steps import *  # noqa

cognite/neat/workflows/steps/lib/{v1 → legacy}/graph_contextualization.py

@@ -7,11 +7,11 @@ from cognite.neat.workflows.steps.data_contracts import SolutionGraph, SourceGra
 from cognite.neat.workflows.steps.step_model import Configurable, Step
 
 __all__ = ["SimpleGraphEntityMatcher"]
-CATEGORY = __name__.split(".")[-1].replace("_", " ").title() + " [VERSION 1]"
+CATEGORY = __name__.split(".")[-1].replace("_", " ").title() + " [LEGACY]"
 
 
 class SimpleGraphEntityMatcher(Step):
-    version = "private-alpha"
+    version = "legacy"
     description = "The step matches entities in the graph and creates links based on provided configurations"
     category = CATEGORY
     configurables: ClassVar[list[Configurable]] = [