cognite-neat 0.75.8__py3-none-any.whl → 0.76.0__py3-none-any.whl

cognite/neat/rules/models/wrapped_entities.py

@@ -0,0 +1,166 @@
+from abc import ABC, abstractmethod
+from collections.abc import Collection
+from functools import total_ordering
+from typing import Any, ClassVar, TypeVar
+
+from cognite.client import data_modeling as dm
+from cognite.client.data_classes.data_modeling import ContainerId, NodeId
+from pydantic import BaseModel, model_serializer, model_validator
+
+from cognite.neat.rules.models.entities import ContainerEntity, DMSNodeEntity, Entity
+
+
+@total_ordering
+class WrappedEntity(BaseModel, ABC):
+    name: ClassVar[str]
+    _inner_cls: ClassVar[type[Entity]]
+    inner: list[Entity] | None
+
+    @classmethod
+    def load(cls: "type[T_WrappedEntity]", data: Any) -> "T_WrappedEntity":
+        if isinstance(data, cls):
+            return data
+        return cls.model_validate(data)
+
+    @model_validator(mode="before")
+    def _load(cls, data: Any) -> dict:
+        if isinstance(data, dict):
+            return data
+        elif not isinstance(data, str):
+            raise ValueError(f"Cannot load {cls.__name__} from {data}")
+        elif not data.casefold().startswith(cls.name.casefold()):
+            raise ValueError(f"Expected {cls.name} but got {data}")
+        result = cls._parse(data)
+        return result
+
+    @classmethod
+    def _parse(cls, data: str) -> dict:
+        if data.casefold() == cls.name.casefold():
+            return {"inner": None}
+        inner = data[len(cls.name) :].removeprefix("(").removesuffix(")")
+        return {"inner": [cls._inner_cls.load(entry.strip()) for entry in inner.split(",")]}
+
+    @model_serializer(when_used="unless-none", return_type=str)
+    def as_str(self) -> str:
+        return str(self)
+
+    def __str__(self):
+        return self.id
+
+    @property
+    def id(self) -> str:
+        inner = self.as_tuple()[1:]
+        return f"{self.name}({','.join(inner)})"
+
+    @property
+    def is_empty(self) -> bool:
+        return self.inner is None or (isinstance(self.inner, list) and not self.inner)
+
+    def dump(self) -> str:
+        return str(self)
+
+    def as_tuple(self) -> tuple[str, ...]:
+        entities: list[str] = [str(inner) for inner in self.inner or []]
+        return self.name, *entities
+
+    def __lt__(self, other: object) -> bool:
+        if not isinstance(other, WrappedEntity):
+            return NotImplemented
+        return self.as_tuple() < other.as_tuple()
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, WrappedEntity):
+            return NotImplemented
+        return self.as_tuple() == other.as_tuple()
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __repr__(self) -> str:
+        return self.id
+
+
+T_WrappedEntity = TypeVar("T_WrappedEntity", bound=WrappedEntity)
+
+
+class DMSFilter(WrappedEntity):
+    @abstractmethod
+    def as_dms_filter(self, default: Any | None = None) -> dm.filters.Filter:
+        raise NotImplementedError
+
+    @classmethod
+    def from_dms_filter(cls, filter: dm.Filter) -> "DMSFilter":
+        dumped = filter.dump()
+        if (body := dumped.get(dm.filters.Equals._filter_name)) and (value := body.get("value")):
+            space = value.get("space")
+            external_id = value.get("externalId")
+            if space is not None and external_id is not None:
+                return NodeTypeFilter(inner=[DMSNodeEntity(space=space, externalId=external_id)])
+        elif (body := dumped.get(dm.filters.In._filter_name)) and (values := body.get("values")):
+            return NodeTypeFilter(
+                inner=[
+                    DMSNodeEntity(space=entry["space"], externalId=entry["externalId"])
+                    for entry in values
+                    if isinstance(entry, dict) and "space" in entry and "externalId" in entry
+                ]
+            )
+        elif body := dumped.get(dm.filters.HasData._filter_name):
+            return HasDataFilter(
+                inner=[
+                    ContainerEntity(space=entry["space"], externalId=entry["externalId"])
+                    for entry in body
+                    if isinstance(entry, dict) and "space" in entry and "externalId" in entry
+                ]
+            )
+
+        raise ValueError(f"Cannot convert {filter._filter_name} to {cls.__name__}")
+
+
+class NodeTypeFilter(DMSFilter):
+    name: ClassVar[str] = "nodeType"
+    _inner_cls: ClassVar[type[DMSNodeEntity]] = DMSNodeEntity
+    inner: list[DMSNodeEntity] | None = None  # type: ignore[assignment]
+
+    @property
+    def nodes(self) -> list[NodeId]:
+        return [node.as_id() for node in self.inner or []]
+
+    def as_dms_filter(self, default: Collection[NodeId] | None = None) -> dm.Filter:
+        if self.inner is not None:
+            node_ids = [node.as_id() for node in self.inner]
+        elif default is not None:
+            node_ids = list(default)
+        else:
+            raise ValueError("Empty nodeType filter, please provide a default node.")
+        if len(node_ids) == 1:
+            return dm.filters.Equals(
+                ["node", "type"], {"space": node_ids[0].space, "externalId": node_ids[0].external_id}
+            )
+        else:
+            return dm.filters.In(
+                ["node", "type"],
+                [
+                    {"space": node.space, "externalId": node.external_id}
+                    for node in sorted(node_ids, key=lambda node: node.as_tuple())
+                ],
+            )
+
+
+class HasDataFilter(DMSFilter):
+    name: ClassVar[str] = "hasData"
+    _inner_cls: ClassVar[type[ContainerEntity]] = ContainerEntity
+    inner: list[ContainerEntity] | None = None  # type: ignore[assignment]
+
+    def as_dms_filter(self, default: Collection[ContainerId] | None = None) -> dm.Filter:
+        containers: list[ContainerId]
+        if self.inner:
+            containers = [container.as_id() for container in self.inner]
+        elif default:
+            containers = list(default)
+        else:
+            raise ValueError("Empty hasData filter, please provide a default containers.")
+
+        return dm.filters.HasData(
+            # Sorting to ensure deterministic order
+            containers=sorted(containers, key=lambda container: container.as_tuple())  # type: ignore[union-attr]
+        )

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}

@@ -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
@@ -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]] = [

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

@@ -29,7 +29,7 @@ __all__ = [
     "ExtractGraphFromDexpiFile",
 ]
 
-CATEGORY = __name__.split(".")[-1].replace("_", " ").title() + " [VERSION 1]"
+CATEGORY = __name__.split(".")[-1].replace("_", " ").title() + " [LEGACY]"
 
 
 class ExtractGraphFromRdfFile(Step):
@@ -38,7 +38,7 @@ class ExtractGraphFromRdfFile(Step):
     """
 
     description = "This step extract instances from a file into the source graph. The file must be in RDF format."
-    version = "private-alpha"
+    version = "legacy"
     category = CATEGORY
     configurables: ClassVar[list[Configurable]] = [
         Configurable(
@@ -91,7 +91,7 @@ class ExtractGraphFromDexpiFile(Step):
     """
 
     description = "This step converts DEXPI P&ID (XML) into Knowledge Graph"
-    version = "private-alpha"
+    version = "legacy"
     category = CATEGORY
     configurables: ClassVar[list[Configurable]] = [
         Configurable(
@@ -130,7 +130,7 @@ class ExtractGraphFromGraphCapturingSheet(Step):
     """
 
     description = "This step extracts nodes and edges from graph capturing spreadsheet and load them into graph"
-    version = "private-alpha"
+    version = "legacy"
     category = CATEGORY
     configurables: ClassVar[list[Configurable]] = [
         Configurable(
@@ -187,7 +187,7 @@ class ExtractGraphFromMockGraph(Step):
     """
 
     description = "This step generate mock graph based on the defined classes and target number of instances"
-    version = "private-alpha"
+    version = "legacy"
     category = CATEGORY
     configurables: ClassVar[list[Configurable]] = [
         Configurable(
@@ -239,7 +239,7 @@ class ExtractGraphFromRulesInstanceSheet(Step):
 
     description = "This step extracts instances from Rules object and loads them into the graph."
     category = CATEGORY
-    version = "private-alpha"
+    version = "legacy"
 
     configurables: ClassVar[list[Configurable]] = [
         Configurable(
@@ -276,7 +276,7 @@ class ExtractGraphFromRulesDataModel(Step):
 
     description = "This step extracts data model from rules file and loads it into source graph."
     category = CATEGORY
-    version = "private-alpha"
+    version = "legacy"
 
     def run(  # type: ignore[override, syntax]
         self, transformation_rules: RulesData, source_graph: SourceGraph
@@ -321,7 +321,7 @@ class ExtractGraphFromJsonFile(Step):
 
     description = "This step extracts instances from json file and loads them into a graph store"
     category = CATEGORY
-    version = "private-alpha"
+    version = "legacy"
     configurables: ClassVar[list[Configurable]] = [
         Configurable(
             name="file_name", value="data_dump.json", label="Full path to the file containing data dump in JSON format"
@@ -504,7 +504,7 @@ class ExtractGraphFromAvevaPiAssetFramework(Step):
 
     description = "This step extracts instances from Aveva PI AF and loads them into a graph store"
     category = CATEGORY
-    version = "private-alpha"
+    version = "legacy"
     configurables: ClassVar[list[Configurable]] = [
         Configurable(
             name="file_name",