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

cognite/neat/utils/cdf/data_classes.py

@@ -268,6 +268,10 @@ class ViewApplyDict(CogniteResourceDict[ViewId, ViewApply]):
     def _as_id(cls, resource: ViewApply) -> ViewId:
         return resource.as_id()
 
+    @classmethod
+    def from_iterable(cls, iterable: Iterable[ViewApply]) -> "ViewApplyDict":
+        return cls({view.as_id(): view for view in iterable})
+
 
 class SpaceApplyDict(CogniteResourceDict[str, SpaceApply]):
     _RESOURCE = SpaceApply
@@ -276,6 +280,10 @@ class SpaceApplyDict(CogniteResourceDict[str, SpaceApply]):
     def _as_id(cls, resource: SpaceApply) -> str:
         return resource.space
 
+    @classmethod
+    def from_iterable(cls, iterable: Iterable[SpaceApply]) -> "SpaceApplyDict":
+        return cls({space.space: space for space in iterable})
+
 
 class ContainerApplyDict(CogniteResourceDict[ContainerId, ContainerApply]):
     _RESOURCE = ContainerApply
@@ -284,6 +292,10 @@ class ContainerApplyDict(CogniteResourceDict[ContainerId, ContainerApply]):
     def _as_id(cls, resource: ContainerApply) -> ContainerId:
         return resource.as_id()
 
+    @classmethod
+    def from_iterable(cls, iterable: Iterable[ContainerApply]) -> "ContainerApplyDict":
+        return cls({container.as_id(): container for container in iterable})
+
 
 class DataModelApplyDict(CogniteResourceDict[DataModelId, DataModelApply]):
     _RESOURCE = DataModelApply
@@ -292,6 +304,10 @@ class DataModelApplyDict(CogniteResourceDict[DataModelId, DataModelApply]):
     def _as_id(cls, resource: DataModelApply) -> DataModelId:
         return resource.as_id()
 
+    @classmethod
+    def from_iterable(cls, iterable: Iterable[DataModelApply]) -> "DataModelApplyDict":
+        return cls({data_model.as_id(): data_model for data_model in iterable})
+
 
 class NodeApplyDict(CogniteResourceDict[NodeId, NodeApply]):
     _RESOURCE = NodeApply
@@ -299,3 +315,7 @@ class NodeApplyDict(CogniteResourceDict[NodeId, NodeApply]):
     @classmethod
     def _as_id(cls, resource: NodeApply) -> NodeId:
         return resource.as_id()
+
+    @classmethod
+    def from_iterable(cls, iterable: Iterable[NodeApply]) -> "NodeApplyDict":
+        return cls({node.as_id(): node for node in iterable})

cognite/neat/utils/regex_patterns.py

@@ -19,6 +19,12 @@ PROPERTY_ID_COMPLIANCE_REGEX = r"^(\*)|(?!^(Property|property)$)(^[a-zA-Z][a-zA-
 VERSION_COMPLIANCE_REGEX = r"^[a-zA-Z0-9]([.a-zA-Z0-9_-]{0,41}[a-zA-Z0-9])?$"
 
 
+# This pattern ignores commas inside brackets
+SPLIT_ON_COMMA_PATTERN = re.compile(r",(?![^(]*\))")
+# This pattern ignores equal signs inside brackets
+SPLIT_ON_EQUAL_PATTERN = re.compile(r"=(?![^(]*\))")
+
+
 class _Patterns:
     @cached_property
     def more_than_one_alphanumeric(self) -> re.Pattern:

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,17 @@ 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.models import RoleTypes
-from cognite.neat.workflows._exceptions import StepNotInitialized
+from cognite.neat.rules._shared import DMSRules, InformationRules, VerifiedRules
+from cognite.neat.rules.models import AssetRules, RoleTypes
+from cognite.neat.rules.transformers import (
+    AssetToInformation,
+    DMSToInformation,
+    InformationToAsset,
+    InformationToDMS,
+    RulesPipeline,
+)
 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 +68,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()
@@ -75,26 +82,30 @@ class DeleteDataModelFromCDF(Step):
                 error_text="No DMS Schema components selected for removal! Please select minimum one!",
                 step_execution_status=StepExecutionStatus.ABORT_AND_FAIL,
             )
-        input_rules = rules.dms or rules.information
+        input_rules = rules.dms or rules.information or rules.asset
         if input_rules is None:
             return FlowMessage(
                 error_text="Missing DMS or Information rules in the input data! "
                 "Please ensure that a DMS or Information rules is provided!",
                 step_execution_status=StepExecutionStatus.ABORT_AND_FAIL,
             )
+        if isinstance(input_rules, DMSRules):
+            dms_rules = input_rules
+        elif isinstance(input_rules, InformationRules):
+            dms_rules = InformationToDMS().transform(input_rules).rules
+        elif isinstance(input_rules, AssetRules):
+            dms_rules = RulesPipeline[AssetRules, DMSRules]([AssetToInformation(), InformationToDMS()]).run(input_rules)
+        else:
+            raise NotImplementedError(f"Unsupported rules type {type(input_rules)}")
 
         dms_exporter = exporters.DMSExporter(
             export_components=frozenset(components_to_delete),
-            include_space=(
-                None
-                if multi_space_components_delete
-                else {input_rules.metadata.space if isinstance(input_rules, DMSRules) else input_rules.metadata.prefix}
-            ),
+            include_space=(None if multi_space_components_delete else {dms_rules.metadata.space}),
         )
 
         report_lines = ["# Data Model Deletion from CDF\n\n"]
         errors = []
-        for result in dms_exporter.delete_from_cdf(rules=input_rules, client=cdf_client, dry_run=dry_run):
+        for result in dms_exporter.delete_from_cdf(rules=dms_rules, client=cdf_client, dry_run=dry_run):
             report_lines.append(str(result))
             errors.extend(result.error_messages)
 
@@ -168,7 +179,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"]
         )
@@ -192,14 +203,18 @@ class RulesToDMS(Step):
                 "Please ensure that a DMS or Information rules is provided!",
                 step_execution_status=StepExecutionStatus.ABORT_AND_FAIL,
             )
+        if isinstance(input_rules, DMSRules):
+            dms_rules = input_rules
+        elif isinstance(input_rules, InformationRules):
+            dms_rules = InformationToDMS().transform(input_rules).rules
+        elif isinstance(input_rules, AssetRules):
+            dms_rules = RulesPipeline[AssetRules, DMSRules]([AssetToInformation(), InformationToDMS()]).run(input_rules)
+        else:
+            raise NotImplementedError(f"Unsupported rules type {type(input_rules)}")
 
         dms_exporter = exporters.DMSExporter(
             export_components=frozenset(components_to_create),
-            include_space=(
-                None
-                if multi_space_components_create
-                else {input_rules.metadata.space if isinstance(input_rules, DMSRules) else input_rules.metadata.prefix}
-            ),
+            include_space=(None if multi_space_components_create else {dms_rules.metadata.space}),
             existing_handling=existing_components_handling,
         )
 
@@ -212,11 +227,11 @@ class RulesToDMS(Step):
         )
         schema_zip = f"{file_name}.zip"
         schema_full_path = output_dir / schema_zip
-        dms_exporter.export_to_file(input_rules, schema_full_path)
+        dms_exporter.export_to_file(dms_rules, schema_full_path)
 
         report_lines = ["# DMS Schema Export to CDF\n\n"]
         errors = []
-        for result in dms_exporter.export_to_cdf_iterable(rules=input_rules, client=cdf_client, dry_run=dry_run):
+        for result in dms_exporter.export_to_cdf_iterable(rules=dms_rules, client=cdf_client, dry_run=dry_run):
             report_lines.append(str(result))
             errors.extend(result.error_messages)
 
@@ -291,12 +306,12 @@ 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"))
         role = self.configs.get("Output role format")
-        output_role = None
+        output_role: RoleTypes | None = None
         if role != "input" and role is not None:
             output_role = RoleTypes[role]
 
@@ -310,23 +325,52 @@ class RulesToExcel(Step):
                 step_execution_status=StepExecutionStatus.ABORT_AND_FAIL,
             )
 
-        excel_exporter = exporters.ExcelExporter(
-            styling=styling,
-            output_role=output_role,
-            dump_as=dump_format,  # type: ignore[arg-type]
-            new_model_id=new_model_id,
-        )
+        excel_exporter = exporters.ExcelExporter(styling=styling, dump_as=dump_format, new_model_id=new_model_id)  # type: ignore[arg-type]
 
-        rule_instance: Rules
+        # Todo - Move the conversion to a separate workflow step.
+        rule_instance: VerifiedRules
         if rules.domain:
             rule_instance = rules.domain
         elif rules.information:
             rule_instance = rules.information
         elif rules.dms:
             rule_instance = rules.dms
+        elif rules.asset:
+            rule_instance = rules.asset
         else:
             output_errors = "No rules provided for export!"
             return FlowMessage(error_text=output_errors, step_execution_status=StepExecutionStatus.ABORT_AND_FAIL)
+
+        if rule_instance.metadata.role is output_role or output_role is None:
+            ...
+        elif output_role is RoleTypes.dms:
+            if isinstance(rule_instance, InformationRules):
+                rule_instance = InformationToDMS().transform(rule_instance).rules
+            elif isinstance(rule_instance, AssetRules):
+                rule_instance = RulesPipeline[AssetRules, DMSRules]([AssetToInformation(), InformationToDMS()]).run(
+                    rule_instance
+                )
+            else:
+                raise NotImplementedError(f"Role {output_role} is not supported for {type(rules).__name__} rules")
+        elif output_role is RoleTypes.information:
+            if isinstance(rule_instance, DMSRules):
+                rule_instance = DMSToInformation().transform(rule_instance).rules
+            elif isinstance(rule_instance, AssetRules):
+                rule_instance = AssetToInformation().transform(rule_instance).rules
+            else:
+                raise NotImplementedError(f"Role {output_role} is not supported for {type(rules).__name__} rules")
+        elif output_role is RoleTypes.asset:
+            if isinstance(rule_instance, InformationRules):
+                rule_instance = InformationToAsset().transform(rule_instance).rules
+            elif isinstance(rule_instance, DMSRules):
+                rule_instance = RulesPipeline[DMSRules, AssetRules]([DMSToInformation(), InformationToAsset()]).run(
+                    rule_instance
+                )
+            else:
+                raise NotImplementedError(f"Role {output_role} is not supported for {type(rules).__name__} rules")
+        else:
+            raise NotImplementedError(f"Role {output_role} is not supported for {type(rules).__name__} rules")
+
         if output_role is None:
             output_role = rule_instance.metadata.role
         output_dir = self.data_store_path / Path("staging")
@@ -369,7 +413,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(
@@ -384,8 +428,16 @@ class RulesToOntology(Step):
         )
         storage_path.parent.mkdir(parents=True, exist_ok=True)
 
+        input_rules = rules.information or rules.dms
+        if isinstance(input_rules, DMSRules):
+            info_rules = DMSToInformation().transform(input_rules).rules
+        elif isinstance(input_rules, InformationRules):
+            info_rules = input_rules
+        else:
+            raise NotImplementedError(f"Unsupported rules type {type(input_rules)}")
+
         exporter = exporters.OWLExporter()
-        exporter.export_to_file(cast(InformationRules | DMSRules, rules.information or rules.dms), storage_path)
+        exporter.export_to_file(info_rules, storage_path)
 
         relative_file_path = "/".join(storage_path.relative_to(self.data_store_path).parts)
 
@@ -420,7 +472,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(
@@ -435,8 +487,16 @@ class RulesToSHACL(Step):
         )
         storage_path.parent.mkdir(parents=True, exist_ok=True)
 
+        input_rules = rules.information or rules.dms
+        if isinstance(input_rules, DMSRules):
+            info_rules = DMSToInformation().transform(input_rules).rules
+        elif isinstance(input_rules, InformationRules):
+            info_rules = input_rules
+        else:
+            raise NotImplementedError(f"Unsupported rules type {type(input_rules)}")
+
         exporter = exporters.SHACLExporter()
-        exporter.export_to_file(cast(InformationRules | DMSRules, rules.information or rules.dms), storage_path)
+        exporter.export_to_file(info_rules, storage_path)
 
         relative_file_path = "/".join(storage_path.relative_to(self.data_store_path).parts)
 
@@ -471,7 +531,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(
@@ -485,9 +545,15 @@ class RulesToSemanticDataModel(Step):
             self.data_store_path / Path(self.configs["File path"]) if self.configs["File path"] else default_path
         )
         storage_path.parent.mkdir(parents=True, exist_ok=True)
-
+        input_rules = rules.information or rules.dms
+        if isinstance(input_rules, DMSRules):
+            info_rules = DMSToInformation().transform(input_rules).rules
+        elif isinstance(input_rules, InformationRules):
+            info_rules = input_rules
+        else:
+            raise NotImplementedError(f"Unsupported rules type {type(input_rules)}")
         exporter = exporters.SemanticDataModelExporter()
-        exporter.export_to_file(cast(InformationRules | DMSRules, rules.information or rules.dms), storage_path)
+        exporter.export_to_file(info_rules, storage_path)
 
         relative_file_path = "/".join(storage_path.relative_to(self.data_store_path).parts)
 
@@ -525,7 +591,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:
@@ -534,28 +600,31 @@ class RulesToCDFTransformations(Step):
                 "Please ensure that a DMS or Information rules is provided!",
                 step_execution_status=StepExecutionStatus.ABORT_AND_FAIL,
             )
-        default_instance_space = (
-            input_rules.metadata.space if isinstance(input_rules, DMSRules) else input_rules.metadata.prefix
-        )
-        instance_space = self.configs.get("Instance space") or default_instance_space
+        if isinstance(input_rules, DMSRules):
+            dms_rules = input_rules
+        elif isinstance(input_rules, InformationRules):
+            dms_rules = InformationToDMS().transform(input_rules).rules
+        elif isinstance(input_rules, AssetRules):
+            dms_rules = RulesPipeline[AssetRules, DMSRules]([AssetToInformation(), InformationToDMS()]).run(input_rules)
+        else:
+            raise NotImplementedError(f"Unsupported rules type {type(input_rules)}")
+
+        instance_space = self.configs.get("Instance space") or dms_rules.metadata.space
         dry_run = self.configs.get("Dry run", "False") == "True"
         dms_exporter = exporters.DMSExporter(
             export_pipeline=True, instance_space=instance_space, export_components=["spaces"]
         )
         output_dir = self.config.staging_path
         output_dir.mkdir(parents=True, exist_ok=True)
-        file_name = (
-            input_rules.metadata.external_id
-            if isinstance(input_rules, DMSRules)
-            else input_rules.metadata.name.replace(" ", "_").lower()
-        )
+        file_name = dms_rules.metadata.external_id.replace(":", "_")
         schema_zip = f"{file_name}_pipeline.zip"
         schema_full_path = output_dir / schema_zip
-        dms_exporter.export_to_file(input_rules, schema_full_path)
+
+        dms_exporter.export_to_file(dms_rules, schema_full_path)
 
         report_lines = ["# DMS Schema Export to CDF\n\n"]
         errors = []
-        for result in dms_exporter.export_to_cdf_iterable(rules=input_rules, client=cdf_client, dry_run=dry_run):
+        for result in dms_exporter.export_to_cdf_iterable(rules=dms_rules, client=cdf_client, dry_run=dry_run):
             report_lines.append(str(result))
             errors.extend(result.error_messages)