cognite-neat 0.77.3__py3-none-any.whl → 0.77.5__py3-none-any.whl

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

@@ -0,0 +1,266 @@
+from collections.abc import Sequence
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Literal, cast, overload
+
+from rdflib import Namespace
+
+from cognite.neat.rules.models._base import DataModelType, ExtensionCategory, SchemaCompleteness, _add_alias
+from cognite.neat.rules.models.data_types import DataType
+from cognite.neat.rules.models.entities import ClassEntity, ParentClassEntity, Unknown, UnknownEntity
+
+from ._rules import InformationClass, InformationMetadata, InformationProperty, InformationRules
+
+
+@dataclass
+class InformationMetadataInput:
+    schema_: Literal["complete", "partial", "extended"]
+    prefix: str
+    namespace: str
+    version: str
+    creator: str
+    data_model_type: Literal["solution", "enterprise"] = "enterprise"
+    extension: Literal["addition", "reshape", "rebuild"] = "addition"
+    name: str | None = None
+    description: str | None = None
+    created: datetime | str | None = None
+    updated: datetime | str | None = None
+    license: str | None = None
+    rights: str | None = None
+
+    @classmethod
+    def load(cls, data: dict[str, Any] | None) -> "InformationMetadataInput | None":
+        if data is None:
+            return None
+        _add_alias(data, InformationMetadata)
+        return cls(
+            data_model_type=data.get("data_model_type", "enterprise"),
+            extension=data.get("extension", "addition"),
+            schema_=data.get("schema_", "partial"),  # type: ignore[arg-type]
+            version=data.get("version"),  # type: ignore[arg-type]
+            namespace=data.get("namespace"),  # type: ignore[arg-type]
+            prefix=data.get("prefix"),  # type: ignore[arg-type]
+            name=data.get("name"),
+            creator=data.get("creator"),  # type: ignore[arg-type]
+            description=data.get("description"),
+            created=data.get("created"),
+            updated=data.get("updated"),
+            license=data.get("license"),
+            rights=data.get("rights"),
+        )
+
+    def dump(self) -> dict[str, Any]:
+        return dict(
+            dataModelType=DataModelType(self.data_model_type),
+            schema=SchemaCompleteness(self.schema_),
+            extension=ExtensionCategory(self.extension),
+            namespace=Namespace(self.namespace),
+            prefix=self.prefix,
+            version=self.version,
+            name=self.name,
+            creator=self.creator,
+            description=self.description,
+            created=self.created or datetime.now(),
+            updated=self.updated or datetime.now(),
+        )
+
+
+@dataclass
+class InformationPropertyInput:
+    class_: str
+    property_: str
+    value_type: str
+    name: str | None = None
+    description: str | None = None
+    comment: str | None = None
+    min_count: int | None = None
+    max_count: int | float | None = None
+    default: Any | None = None
+    reference: str | None = None
+    match_type: str | None = None
+    rule_type: str | None = None
+    rule: str | None = None
+
+    @classmethod
+    @overload
+    def load(cls, data: None) -> None: ...
+
+    @classmethod
+    @overload
+    def load(cls, data: dict[str, Any]) -> "InformationPropertyInput": ...
+
+    @classmethod
+    @overload
+    def load(cls, data: list[dict[str, Any]]) -> list["InformationPropertyInput"]: ...
+
+    @classmethod
+    def load(
+        cls, data: dict[str, Any] | list[dict[str, Any]] | None
+    ) -> "InformationPropertyInput | list[InformationPropertyInput] | None":
+        if data is None:
+            return None
+        if isinstance(data, list) or (isinstance(data, dict) and isinstance(data.get("data"), list)):
+            items = cast(list[dict[str, Any]], data.get("data") if isinstance(data, dict) else data)
+            return [loaded for item in items if (loaded := cls.load(item)) is not None]
+
+        _add_alias(data, InformationProperty)
+        return cls(
+            class_=data.get("class_"),  # type: ignore[arg-type]
+            property_=data.get("property_"),  # type: ignore[arg-type]
+            name=data.get("name", None),
+            description=data.get("description", None),
+            comment=data.get("comment", None),
+            value_type=data.get("value_type"),  # type: ignore[arg-type]
+            min_count=data.get("min_count", None),
+            max_count=data.get("max_count", None),
+            default=data.get("default", None),
+            reference=data.get("reference", None),
+            match_type=data.get("match_type", None),
+            rule_type=data.get("rule_type", None),
+            rule=data.get("rule", None),
+        )
+
+    def dump(self, default_prefix: str) -> dict[str, Any]:
+        value_type: DataType | ClassEntity | UnknownEntity
+
+        # property holding xsd data type
+        if DataType.is_data_type(self.value_type):
+            value_type = DataType.load(self.value_type)
+
+        # unknown value type
+        elif self.value_type == str(Unknown):
+            value_type = UnknownEntity()
+
+        # property holding link to class
+        else:
+            value_type = ClassEntity.load(self.value_type, prefix=default_prefix)
+
+        return {
+            "Class": ClassEntity.load(self.class_, prefix=default_prefix),
+            "Property": self.property_,
+            "Name": self.name,
+            "Description": self.description,
+            "Comment": self.comment,
+            "Value Type": value_type,
+            "Min Count": self.min_count,
+            "Max Count": self.max_count,
+            "Default": self.default,
+            "Reference": self.reference,
+            "Match Type": self.match_type,
+            "Rule Type": self.rule_type,
+            "Rule": self.rule,
+        }
+
+
+@dataclass
+class InformationClassInput:
+    class_: str
+    name: str | None = None
+    description: str | None = None
+    comment: str | None = None
+    parent: str | None = None
+    reference: str | None = None
+    match_type: str | None = None
+
+    @classmethod
+    @overload
+    def load(cls, data: None) -> None: ...
+
+    @classmethod
+    @overload
+    def load(cls, data: dict[str, Any]) -> "InformationClassInput": ...
+
+    @classmethod
+    @overload
+    def load(cls, data: list[dict[str, Any]]) -> list["InformationClassInput"]: ...
+
+    @classmethod
+    def load(
+        cls, data: dict[str, Any] | list[dict[str, Any]] | None
+    ) -> "InformationClassInput | list[InformationClassInput] | None":
+        if data is None:
+            return None
+        if isinstance(data, list) or (isinstance(data, dict) and isinstance(data.get("data"), list)):
+            items = cast(list[dict[str, Any]], data.get("data") if isinstance(data, dict) else data)
+            return [loaded for item in items if (loaded := cls.load(item)) is not None]
+        _add_alias(data, InformationClass)
+        return cls(
+            class_=data.get("class_"),  # type: ignore[arg-type]
+            name=data.get("name", None),
+            description=data.get("description", None),
+            comment=data.get("comment", None),
+            parent=data.get("parent", None),
+            reference=data.get("reference", None),
+            match_type=data.get("match_type", None),
+        )
+
+    def dump(self, default_prefix: str) -> dict[str, Any]:
+        return {
+            "Class": ClassEntity.load(self.class_, prefix=default_prefix),
+            "Name": self.name,
+            "Description": self.description,
+            "Comment": self.comment,
+            "Reference": self.reference,
+            "Match Type": self.match_type,
+            "Parent Class": (
+                [ParentClassEntity.load(parent, prefix=default_prefix) for parent in self.parent.split(",")]
+                if self.parent
+                else None
+            ),
+        }
+
+
+@dataclass
+class InformationRulesInput:
+    metadata: InformationMetadataInput
+    properties: Sequence[InformationPropertyInput]
+    classes: Sequence[InformationClassInput]
+    last: "InformationRulesInput | InformationRules | None" = None
+    reference: "InformationRulesInput | InformationRules | None" = None
+
+    @classmethod
+    @overload
+    def load(cls, data: dict[str, Any]) -> "InformationRulesInput": ...
+
+    @classmethod
+    @overload
+    def load(cls, data: None) -> None: ...
+
+    @classmethod
+    def load(cls, data: dict | None) -> "InformationRulesInput | None":
+        if data is None:
+            return None
+        _add_alias(data, InformationRules)
+
+        return cls(
+            metadata=InformationMetadataInput.load(data.get("metadata")),  # type: ignore[arg-type]
+            properties=InformationPropertyInput.load(data.get("properties")),  # type: ignore[arg-type]
+            classes=InformationClassInput.load(data.get("classes")),  # type: ignore[arg-type]
+            last=InformationRulesInput.load(data.get("last")),
+            reference=InformationRulesInput.load(data.get("reference")),
+        )
+
+    def as_rules(self) -> InformationRules:
+        return InformationRules.model_validate(self.dump())
+
+    def dump(self) -> dict[str, Any]:
+        default_prefix = self.metadata.prefix
+        reference: dict[str, Any] | None = None
+        if isinstance(self.reference, InformationRulesInput):
+            reference = self.reference.dump()
+        elif isinstance(self.reference, InformationRules):
+            # We need to load through the InformationRulesInput to set the correct default space and version
+            reference = InformationRulesInput.load(self.reference.model_dump()).dump()
+        last: dict[str, Any] | None = None
+        if isinstance(self.last, InformationRulesInput):
+            last = self.last.dump()
+        elif isinstance(self.last, InformationRules):
+            # We need to load through the InformationRulesInput to set the correct default space and version
+            last = InformationRulesInput.load(self.last.model_dump()).dump()
+        return dict(
+            Metadata=self.metadata.dump(),
+            Properties=[prop.dump(default_prefix) for prop in self.properties],
+            Classes=[class_.dump(default_prefix) for class_ in self.classes],
+            Last=last,
+            Reference=reference,
+        )

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

@@ -0,0 +1,73 @@
+from typing import Any, ClassVar
+
+from cognite.neat.rules.models import InformationRules
+from cognite.neat.rules.models.entities import ClassEntity, ReferenceEntity
+from cognite.neat.rules.models.information import InformationClass, InformationProperty
+
+
+class _InformationRulesSerializer:
+    # These are the fields that need to be cleaned from the default space and version
+    PROPERTIES_FIELDS: ClassVar[list[str]] = ["class_", "value_type"]
+    CLASSES_FIELDS: ClassVar[list[str]] = ["class_"]
+
+    def __init__(self, by_alias: bool, default_prefix: str) -> None:
+        self.default_prefix = f"{default_prefix}:"
+
+        self.properties_fields = self.PROPERTIES_FIELDS
+        self.classes_fields = self.CLASSES_FIELDS
+
+        self.prop_name = "properties"
+        self.class_name = "classes"
+        self.metadata_name = "metadata"
+        self.class_parent = "parent"
+
+        self.prop_property = "property_"
+        self.prop_class = "class_"
+
+        self.reference = "Reference" if by_alias else "reference"
+        if by_alias:
+            self.properties_fields = [
+                InformationProperty.model_fields[field].alias or field for field in self.properties_fields
+            ]
+            self.classes_fields = [InformationClass.model_fields[field].alias or field for field in self.classes_fields]
+            self.prop_name = InformationRules.model_fields[self.prop_name].alias or self.prop_name
+            self.class_name = InformationRules.model_fields[self.class_name].alias or self.class_name
+            self.class_parent = InformationClass.model_fields[self.class_parent].alias or self.class_parent
+            self.metadata_name = InformationRules.model_fields[self.metadata_name].alias or self.metadata_name
+
+            self.prop_property = InformationProperty.model_fields[self.prop_property].alias or self.prop_property
+            self.prop_class = InformationProperty.model_fields[self.prop_class].alias or self.prop_class
+
+    def clean(self, dumped: dict[str, Any], as_reference: bool) -> dict[str, Any]:
+        # Sorting to get a deterministic order
+        dumped[self.prop_name] = sorted(
+            dumped[self.prop_name]["data"], key=lambda p: (p[self.prop_class], p[self.prop_property])
+        )
+        dumped[self.class_name] = sorted(dumped[self.class_name]["data"], key=lambda v: v[self.prop_class])
+
+        for prop in dumped[self.prop_name]:
+            if as_reference:
+                class_entity = ClassEntity.load(prop[self.prop_class])
+                prop[self.reference] = str(
+                    ReferenceEntity(
+                        prefix=str(class_entity.prefix), suffix=class_entity.suffix, property=prop[self.prop_property]
+                    )
+                )
+
+            for field_name in self.properties_fields:
+                if value := prop.get(field_name):
+                    prop[field_name] = value.removeprefix(self.default_prefix)
+
+        for class_ in dumped[self.class_name]:
+            if as_reference:
+                class_[self.reference] = class_[self.prop_class]
+            for field_name in self.classes_fields:
+                if value := class_.get(field_name):
+                    class_[field_name] = value.removeprefix(self.default_prefix)
+
+            if value := class_.get(self.class_parent):
+                class_[self.class_parent] = ",".join(
+                    parent.strip().removeprefix(self.default_prefix) for parent in value.split(",")
+                )
+
+        return dumped

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

@@ -0,0 +1,164 @@
+import itertools
+from typing import cast
+
+from cognite.neat.rules import issues
+from cognite.neat.rules.issues import IssueList
+from cognite.neat.rules.models._base import DataModelType, SchemaCompleteness
+from cognite.neat.rules.models.entities import ClassEntity, EntityTypes, UnknownEntity
+from cognite.neat.utils.utils import get_inheritance_path
+
+from ._rules import InformationRules
+
+
+class InformationPostValidation:
+    """This class does all the validation of the Information rules that have dependencies
+    between components."""
+
+    def __init__(self, rules: InformationRules):
+        self.rules = rules
+        self.metadata = rules.metadata
+        self.properties = rules.properties
+        self.classes = rules.classes
+        self.issue_list = IssueList()
+
+    def validate(self) -> IssueList:
+        if self.metadata.schema_ == SchemaCompleteness.partial:
+            return self.issue_list
+
+        if self.metadata.data_model_type == DataModelType.solution and not self.rules.reference:
+            raise ValueError("Reference data model is missing")
+
+        if self.metadata.schema_ == SchemaCompleteness.extended and not self.rules.last:
+            raise ValueError("Last version is missing")
+
+        self._dangling_classes()
+        self._referenced_parent_classes_exist()
+        self._referenced_classes_exist()
+        self._referenced_value_types_exist()
+
+        return self.issue_list
+
+    def _dangling_classes(self) -> None:
+        # needs to be complete for this validation to pass
+        defined_classes = {class_.class_ for class_ in self.classes}
+        referred_classes = {property_.class_ for property_ in self.properties}
+        class_parent_pairs = self._class_parent_pairs()
+        dangling_classes = set()
+
+        if classes_without_properties := defined_classes.difference(referred_classes):
+            for class_ in classes_without_properties:
+                # USE CASE: class has no direct properties and no parents
+                if class_ not in class_parent_pairs:
+                    dangling_classes.add(class_)
+                # USE CASE: class has no direct properties and no parents with properties
+                elif class_ not in class_parent_pairs and not any(
+                    parent in referred_classes for parent in get_inheritance_path(class_, class_parent_pairs)
+                ):
+                    dangling_classes.add(class_)
+
+        if dangling_classes:
+            self.issue_list.append(
+                issues.spreadsheet.ClassNoPropertiesNoParentError([class_.versioned_id for class_ in dangling_classes])
+            )
+
+    def _referenced_parent_classes_exist(self) -> None:
+        # needs to be complete for this validation to pass
+        class_parent_pairs = self._class_parent_pairs()
+        classes = set(class_parent_pairs.keys())
+        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])
+            )
+
+    def _referenced_classes_exist(self) -> None:
+        # needs to be complete for this validation to pass
+        defined_classes = {class_.class_ for class_ in self.classes}
+        referred_classes = {property_.class_ for property_ in self.properties}
+
+        # USE CASE: models are complete
+        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]
+                )
+            )
+
+        # 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]
+                    )
+                )
+
+    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
+        defined_classes = {class_.class_ for class_ in self.classes} | {UnknownEntity()}
+        referred_object_types = {
+            property_.value_type
+            for property_ in self.rules.properties
+            if property_.type_ == EntityTypes.object_property
+        }
+
+        # USE CASE: models are complete
+        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]
+                )
+            )
+
+        # 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]
+                    )
+                )
+
+    def _class_parent_pairs(self) -> dict[ClassEntity, list[ClassEntity]]:
+        class_subclass_pairs: dict[ClassEntity, list[ClassEntity]] = {}
+
+        classes = self.rules.model_copy(deep=True).classes.data
+
+        # USE CASE: Solution model being extended (user + last + reference = complete)
+        if (
+            self.metadata.schema_ == SchemaCompleteness.extended
+            and self.metadata.data_model_type == DataModelType.solution
+        ):
+            classes += (
+                cast(InformationRules, self.rules.last).model_copy(deep=True).classes.data
+                + cast(InformationRules, self.rules.reference).model_copy(deep=True).classes.data
+            )
+
+        # USE CASE: Solution model being created from scratch (user + reference = complete)
+        elif (
+            self.metadata.schema_ == SchemaCompleteness.complete
+            and self.metadata.data_model_type == DataModelType.solution
+        ):
+            classes += cast(InformationRules, self.rules.reference).model_copy(deep=True).classes.data
+
+        # USE CASE: Enterprise model being extended (user + last = complete)
+        elif (
+            self.metadata.schema_ == SchemaCompleteness.extended
+            and self.metadata.data_model_type == DataModelType.enterprise
+        ):
+            classes += cast(InformationRules, self.rules.last).model_copy(deep=True).classes.data
+
+        for class_ in classes:
+            class_subclass_pairs[class_.class_] = []
+            if class_.parent is None:
+                continue
+            class_subclass_pairs[class_.class_].extend([parent.as_class_entity() for parent in class_.parent])
+
+        return class_subclass_pairs

cognite/neat/utils/cdf.py

@@ -1,3 +1,5 @@
+from cognite.client import CogniteClient
+from cognite.client.data_classes import filters
 from pydantic import BaseModel, field_validator
 
 
@@ -22,3 +24,36 @@ class InteractiveCogniteClient(CogniteClientConfig):
 class ServiceCogniteClient(CogniteClientConfig):
     token_url: str = "https://login.microsoftonline.com/common/oauth2/token"
     client_secret: str = "secret"
+
+
+def clean_space(client: CogniteClient, space: str) -> None:
+    """Deletes all data in a space.
+
+    This means all nodes, edges, views, containers, and data models located in the given space.
+
+    Args:
+        client: Connected CogniteClient
+        space: The space to delete.
+
+    """
+    edges = client.data_modeling.instances.list("edge", limit=-1, filter=filters.Equals(["edge", "space"], space))
+    if edges:
+        instances = client.data_modeling.instances.delete(edges=edges.as_ids())
+        print(f"Deleted {len(instances.edges)} edges")
+    nodes = client.data_modeling.instances.list("node", limit=-1, filter=filters.Equals(["node", "space"], space))
+    if nodes:
+        instances = client.data_modeling.instances.delete(nodes=nodes.as_ids())
+        print(f"Deleted {len(instances.nodes)} nodes")
+    views = client.data_modeling.views.list(limit=-1, space=space)
+    if views:
+        deleted_views = client.data_modeling.views.delete(views.as_ids())
+        print(f"Deleted {len(deleted_views)} views")
+    containers = client.data_modeling.containers.list(limit=-1, space=space)
+    if containers:
+        deleted_containers = client.data_modeling.containers.delete(containers.as_ids())
+        print(f"Deleted {len(deleted_containers)} containers")
+    if data_models := client.data_modeling.data_models.list(limit=-1, space=space):
+        deleted_data_models = client.data_modeling.data_models.delete(data_models.as_ids())
+        print(f"Deleted {len(deleted_data_models)} data models")
+    deleted_space = client.data_modeling.spaces.delete(space)
+    print(f"Deleted space {deleted_space}")

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

@@ -269,10 +269,19 @@ class RulesToExcel(Step):
             options=["input", *RoleTypes.__members__.keys()],
         ),
         Configurable(
-            name="Is Reference",
-            value="False",
-            label="Export rules as reference rules. If provided, the rules will be exported as reference rules. ",
-            options=["True", "False"],
+            name="Dump Format",
+            value="user",
+            label="How to dump the rules to the Excel file.\n"
+            "'user' - just as is.\n'reference' - enterprise model used as basis for a solution model\n"
+            "'last' - used when updating a data model.",
+            options=list(exporters.ExcelExporter.dump_options),
+        ),
+        Configurable(
+            name="New Data Model ID",
+            value="",
+            label="If you chose Dump Format 'reference', the provided ID will be use in the new medata sheet. "
+            "Expected format 'sp_space:my_external_id'.",
+            options=list(exporters.ExcelExporter.dump_options),
         ),
         Configurable(
             name="File path",
@@ -285,15 +294,29 @@ class RulesToExcel(Step):
         if self.configs is None or self.data_store_path is None:
             raise StepNotInitialized(type(self).__name__)
 
-        is_reference = self.configs.get("Is Reference") == "True"
+        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
         if role != "input" and role is not None:
             output_role = RoleTypes[role]
 
-        dump_as = "reference" if is_reference else "user"
-        excel_exporter = exporters.ExcelExporter(styling=styling, output_role=output_role, dump_as=dump_as)  # type: ignore[arg-type]
+        new_model_str = self.configs.get("New Data Model ID")
+        new_model_id: tuple[str, str] | None = None
+        if new_model_str and ":" in new_model_str:
+            new_model_id = tuple(new_model_str.split(":", 1))  # type: ignore[assignment]
+        elif new_model_str:
+            return FlowMessage(
+                error_text="New Data Model ID must be in the format 'sp_space:my_external_id'!",
+                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,
+        )
 
         rule_instance: Rules
         if rules.domain:

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

@@ -3,6 +3,7 @@ from pathlib import Path
 from typing import ClassVar
 
 from cognite.client import CogniteClient
+from cognite.client.data_classes.data_modeling import DataModelId
 
 from cognite.neat.rules import importers
 from cognite.neat.rules.issues.formatters import FORMATTER_BY_NAME
@@ -184,6 +185,13 @@ class DMSToRules(Step):
             type="string",
             required=True,
         ),
+        Configurable(
+            name="Reference data model id",
+            value=None,
+            label="The ID of the Reference Data Model to import. Written at 'my_space:my_data_model(version=1)'. "
+            "This is typically an enterprise data model when you want to import a solution model",
+            type="string",
+        ),
         Configurable(
             name="Report formatter",
             value=next(iter(FORMATTER_BY_NAME.keys())),
@@ -214,8 +222,19 @@ class DMSToRules(Step):
                 f"or 'my_space:my_data_model', failed to parse space from {datamodel_id_str}"
             )
             return FlowMessage(error_text=error_text, step_execution_status=StepExecutionStatus.ABORT_AND_FAIL)
-
-        dms_importer = importers.DMSImporter.from_data_model_id(cdf_client, datamodel_entity.as_id())
+        ref_datamodel_str = self.configs.get("Reference data model id", "")
+        ref_model_id: DataModelId | None = None
+        if ref_datamodel_str:
+            ref_model = DataModelEntity.load(ref_datamodel_str)
+            if isinstance(ref_model, DMSUnknownEntity):
+                error_text = (
+                    f"Reference 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 {ref_datamodel_str}"
+                )
+                return FlowMessage(error_text=error_text, step_execution_status=StepExecutionStatus.ABORT_AND_FAIL)
+            ref_model_id = ref_model.as_id()
+
+        dms_importer = importers.DMSImporter.from_data_model_id(cdf_client, datamodel_entity.as_id(), ref_model_id)
 
         # if role is None, it will be inferred from the rules file
         role = self.configs.get("Role")

{cognite_neat-0.77.3.dist-info → cognite_neat-0.77.5.dist-info}/METADATA

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