cognite-neat 0.99.1__py3-none-any.whl → 0.100.1__py3-none-any.whl

cognite/neat/_rules/transformers/_mapping.py

@@ -4,13 +4,16 @@ from collections import defaultdict
 from functools import cached_property
 from typing import Any, ClassVar, Literal
 
-from cognite.neat._issues.errors import NeatValueError
+from cognite.client import data_modeling as dm
+
+from cognite.neat._client import NeatClient
+from cognite.neat._issues.errors import CDFMissingClientError, NeatValueError, ResourceNotFoundError
 from cognite.neat._issues.warnings import NeatValueWarning, PropertyOverwritingWarning
 from cognite.neat._rules._shared import JustRules, OutRules
 from cognite.neat._rules.models import DMSRules, SheetList
 from cognite.neat._rules.models.data_types import Enum
 from cognite.neat._rules.models.dms import DMSEnum, DMSProperty, DMSView
-from cognite.neat._rules.models.entities import ViewEntity
+from cognite.neat._rules.models.entities import ContainerEntity, ViewEntity
 
 from ._base import RulesTransformer
 
@@ -208,3 +211,130 @@ class RuleMapper(RulesTransformer[DMSRules, DMSRules]):
                     # These are used for warnings so we use the alias to make it more readable for the user
                     conflicts.append(mapping_prop.model_fields[field_name].alias or field_name)
         return to_overwrite, conflicts
+
+
+class AsParentPropertyId(RulesTransformer[DMSRules, DMSRules]):
+    """Looks up all view properties that map to the same container property,
+    and changes the child view property id to match the parent property id.
+    """
+
+    def __init__(self, client: NeatClient | None = None) -> None:
+        self._client = client
+
+    def transform(self, rules: DMSRules | OutRules[DMSRules]) -> JustRules[DMSRules]:
+        input_rules = self._to_rules(rules)
+        new_rules = input_rules.model_copy(deep=True)
+        new_rules.metadata.version += "_as_parent_name"
+
+        path_by_view = self._inheritance_path_by_view(new_rules)
+        view_by_container_property = self._view_by_container_properties(new_rules)
+
+        parent_view_property_by_container_property = self._get_parent_view_property_by_container_property(
+            path_by_view, view_by_container_property
+        )
+
+        for prop in new_rules.properties:
+            if prop.container and prop.container_property:
+                if parent_name := parent_view_property_by_container_property.get(
+                    (prop.container, prop.container_property)
+                ):
+                    prop.view_property = parent_name
+
+        return JustRules(new_rules)
+
+    # Todo: Move into Probe class. Note this means that the Probe class must take a NeatClient as an argument.
+    def _inheritance_path_by_view(self, rules: DMSRules) -> dict[ViewEntity, list[ViewEntity]]:
+        parents_by_view: dict[ViewEntity, list[ViewEntity]] = {view.view: view.implements or [] for view in rules.views}
+
+        path_by_view: dict[ViewEntity, list[ViewEntity]] = {}
+        for view in rules.views:
+            path_by_view[view.view] = self._get_inheritance_path(
+                view.view, parents_by_view, rules.metadata.as_data_model_id()
+            )
+        return path_by_view
+
+    def _get_inheritance_path(
+        self, view: ViewEntity, parents_by_view: dict[ViewEntity, list[ViewEntity]], data_model_id: dm.DataModelId
+    ) -> list[ViewEntity]:
+        if parents_by_view.get(view) == []:
+            # We found the root.
+            return [view]
+        if view not in parents_by_view and self._client is not None:
+            # Lookup the parent
+            view_id = view.as_id()
+            read_views = self._client.loaders.views.retrieve([view_id])
+            if not read_views:
+                # Warning? Should be caught by validation
+                raise ResourceNotFoundError(view_id, "view", data_model_id, "data model")
+            parent_view_latest = max(read_views, key=lambda view: view.created_time)
+            parents_by_view[ViewEntity.from_id(parent_view_latest.as_id())] = [
+                ViewEntity.from_id(grand_parent) for grand_parent in parent_view_latest.implements or []
+            ]
+        elif view not in parents_by_view:
+            raise CDFMissingClientError(
+                f"The data model {data_model_id} is referencing a view that is not in the data model."
+                f"Please provide a client to lookup the view."
+            )
+
+        inheritance_path = [view]
+        seen = {view}
+        if view in parents_by_view:
+            for parent in parents_by_view[view]:
+                parent_path = self._get_inheritance_path(parent, parents_by_view, data_model_id)
+                inheritance_path.extend([p for p in parent_path if p not in seen])
+                seen.update(parent_path)
+        return inheritance_path
+
+    def _view_by_container_properties(
+        self, rules: DMSRules
+    ) -> dict[tuple[ContainerEntity, str], list[tuple[ViewEntity, str]]]:
+        view_properties_by_container_properties: dict[tuple[ContainerEntity, str], list[tuple[ViewEntity, str]]] = (
+            defaultdict(list)
+        )
+        view_with_properties: set[ViewEntity] = set()
+        for prop in rules.properties:
+            if not prop.container or not prop.container_property:
+                continue
+            view_properties_by_container_properties[(prop.container, prop.container_property)].append(
+                (prop.view, prop.view_property)
+            )
+            view_with_properties.add(prop.view)
+
+        # We need to look up all parent properties.
+        to_lookup = {view.view.as_id() for view in rules.views if view.view not in view_with_properties}
+        if to_lookup and self._client is None:
+            raise CDFMissingClientError(
+                f"Views {to_lookup} are not in the data model. Please provide a client to lookup the views."
+            )
+        elif to_lookup and self._client:
+            read_views = self._client.loaders.views.retrieve(list(to_lookup), include_ancestor=True)
+            write_views = [self._client.loaders.views.as_write(read_view) for read_view in read_views]
+            # We use the write/request format of the views as the read/response format contains all properties
+            # including ancestor properties. The goal is to find the property name used in the parent
+            # and thus we cannot have that repeated in the child views.
+            for write_view in write_views:
+                view_id = write_view.as_id()
+                view_entity = ViewEntity.from_id(view_id)
+
+                for property_id, property_ in (write_view.properties or {}).items():
+                    if not isinstance(property_, dm.MappedPropertyApply):
+                        continue
+                    container_entity = ContainerEntity.from_id(property_.container)
+                    view_properties_by_container_properties[
+                        (container_entity, property_.container_property_identifier)
+                    ].append((view_entity, property_id))
+
+        return view_properties_by_container_properties
+
+    @staticmethod
+    def _get_parent_view_property_by_container_property(
+        path_by_view, view_by_container_properties: dict[tuple[ContainerEntity, str], list[tuple[ViewEntity, str]]]
+    ) -> dict[tuple[ContainerEntity, str], str]:
+        parent_name_by_container_property: dict[tuple[ContainerEntity, str], str] = {}
+        for (container, container_property), view_properties in view_by_container_properties.items():
+            if len(view_properties) == 1:
+                continue
+            # Shortest path is the parent
+            _, prop_name = min(view_properties, key=lambda prop: len(path_by_view[prop[0]]))
+            parent_name_by_container_property[(container, container_property)] = prop_name
+        return parent_name_by_container_property

cognite/neat/_session/_base.py

@@ -15,7 +15,7 @@ from cognite.neat._rules.models.dms import DMSValidation
 from cognite.neat._rules.models.information import InformationValidation
 from cognite.neat._rules.models.information._rules import InformationRules
 from cognite.neat._rules.models.information._rules_input import InformationInputRules
-from cognite.neat._rules.transformers import ConvertToRules, VerifyAnyRules
+from cognite.neat._rules.transformers import ConvertToRules, InformationToDMS, VerifyAnyRules
 from cognite.neat._rules.transformers._converters import ConversionTransformer
 from cognite.neat._store._provenance import (
     INSTANCES_ENTITY,
@@ -54,7 +54,7 @@ class NeatSession:
         self.show = ShowAPI(self._state)
         self.set = SetAPI(self._state, verbose)
         self.inspect = InspectAPI(self._state)
-        self.mapping = MappingAPI(self._state)
+        self.mapping = MappingAPI(self._state, self._client)
         self.drop = DropAPI(self._state)
         self.opt = OptAPI()
         self.opt._display()
@@ -70,35 +70,37 @@ class NeatSession:
         transformer = VerifyAnyRules("continue", validate=False)
         start = datetime.now(timezone.utc)
         output = transformer.try_transform(last_unverified_rule)
-        if isinstance(output.rules, DMSRules):
-            issues = DMSValidation(output.rules, self._client).validate()
-        elif isinstance(output.rules, InformationRules):
-            issues = InformationValidation(output.rules).validate()
-        else:
-            raise NeatSessionError("Unsupported rule type")
-        if issues.has_errors:
-            # This is up for discussion, but I think we should not return rules that
-            # only pass the verification but not the validation.
-            output.rules = None
-        output.issues.extend(issues)
-
-        end = datetime.now(timezone.utc)
 
         if output.rules:
-            change = Change.from_rules_activity(
-                output.rules,
-                transformer.agent,
-                start,
-                end,
-                f"Verified data model {source_id} as {output.rules.metadata.identifier}",
-                self._state.data_model.provenance.source_entity(source_id)
-                or self._state.data_model.provenance.target_entity(source_id),
-            )
-
-            self._state.data_model.write(output.rules, change)
-
-            if isinstance(output.rules, InformationRules):
-                self._state.instances.store.add_rules(output.rules)
+            if isinstance(output.rules, DMSRules):
+                issues = DMSValidation(output.rules, self._client).validate()
+            elif isinstance(output.rules, InformationRules):
+                issues = InformationValidation(output.rules).validate()
+            else:
+                raise NeatSessionError("Unsupported rule type")
+            if issues.has_errors:
+                # This is up for discussion, but I think we should not return rules that
+                # only pass the verification but not the validation.
+                output.rules = None
+            output.issues.extend(issues)
+
+            end = datetime.now(timezone.utc)
+
+            if output.rules:
+                change = Change.from_rules_activity(
+                    output.rules,
+                    transformer.agent,
+                    start,
+                    end,
+                    f"Verified data model {source_id} as {output.rules.metadata.identifier}",
+                    self._state.data_model.provenance.source_entity(source_id)
+                    or self._state.data_model.provenance.target_entity(source_id),
+                )
+
+                self._state.data_model.write(output.rules, change)
+
+                if isinstance(output.rules, InformationRules):
+                    self._state.instances.store.add_rules(output.rules)
 
         output.issues.action = "verify"
         self._state.data_model.issue_lists.append(output.issues)
@@ -106,7 +108,16 @@ class NeatSession:
             print("You can inspect the issues with the .inspect.issues(...) method.")
         return output.issues
 
-    def convert(self, target: Literal["dms", "information"]) -> IssueList:
+    def convert(
+        self, target: Literal["dms", "information"], mode: Literal["edge_properties"] | None = None
+    ) -> IssueList:
+        """Converts the last verified data model to the target type.
+
+        Args:
+            target: The target type to convert the data model to.
+            mode: If the target is "dms", the mode to use for the conversion. None is used for default conversion.
+                "edge_properties" treas classes that implements Edge as edge properties.
+        """
         start = datetime.now(timezone.utc)
         issues = IssueList()
         converter: ConversionTransformer | None = None
@@ -114,7 +125,7 @@ class NeatSession:
         with catch_issues(issues):
             if target == "dms":
                 source_id, info_rules = self._state.data_model.last_verified_information_rules
-                converter = ConvertToRules(DMSRules)
+                converter = InformationToDMS(mode=mode)
                 converted_rules = converter.transform(info_rules).rules
             elif target == "information":
                 source_id, dms_rules = self._state.data_model.last_verified_dms_rules

cognite/neat/_session/_mapping.py

@@ -1,28 +1,50 @@
 from datetime import datetime, timezone
 
+from cognite.neat._client import NeatClient
+from cognite.neat._constants import DEFAULT_NAMESPACE
+from cognite.neat._rules.importers import DMSImporter
+from cognite.neat._rules.models.dms import DMSValidation
 from cognite.neat._rules.models.mapping import load_classic_to_core_mapping
-from cognite.neat._rules.transformers import RuleMapper
+from cognite.neat._rules.transformers import AsParentPropertyId, RuleMapper, VerifyDMSRules
+from cognite.neat._store._provenance import Agent as ProvenanceAgent
 from cognite.neat._store._provenance import Change
 
 from ._state import SessionState
-from .exceptions import session_class_wrapper
+from .exceptions import NeatSessionError, session_class_wrapper
 
 
 @session_class_wrapper
 class MappingAPI:
-    def __init__(self, state: SessionState):
+    def __init__(self, state: SessionState, client: NeatClient | None = None):
+        self.data_model = DataModelMappingAPI(state, client)
+
+
+@session_class_wrapper
+class DataModelMappingAPI:
+    def __init__(self, state: SessionState, client: NeatClient | None = None):
         self._state = state
+        self._client = client
 
-    def classic_to_core(self, org_name: str) -> None:
+    def classic_to_core(self, company_prefix: str, use_parent_property_name: bool = True) -> None:
         """Map classic types to core types.
 
         Note this automatically creates an extended CogniteCore model.
 
+        Args:
+            company_prefix: Prefix used for all extended CogniteCore types.
+            use_parent_property_name: Whether to use the parent property name in the extended CogniteCore model.
+                See below for more information.
+
+        If you extend CogniteAsset, with for example, ClassicAsset. You will map the property `parentId` to `parent`.
+        If you set `user_parent_property_name` to True, the `parentId` will be renamed to `parent` after the
+        mapping is done. If you set it to False, the property will remain `parentId`.
         """
         source_id, rules = self._state.data_model.last_verified_dms_rules
 
         start = datetime.now(timezone.utc)
-        transformer = RuleMapper(load_classic_to_core_mapping(org_name, rules.metadata.space, rules.metadata.version))
+        transformer = RuleMapper(
+            load_classic_to_core_mapping(company_prefix, rules.metadata.space, rules.metadata.version)
+        )
         output = transformer.transform(rules)
         end = datetime.now(timezone.utc)
 
@@ -37,3 +59,81 @@ class MappingAPI:
         )
 
         self._state.data_model.write(output.rules, change)
+
+        start = datetime.now(timezone.utc)
+
+        source_id, rules = self._state.data_model.last_verified_dms_rules
+        view_ids, container_ids = DMSValidation(rules, self._client).imported_views_and_containers_ids()
+        if not (view_ids or container_ids):
+            print(
+                f"Data model {rules.metadata.as_data_model_id()} does not have any referenced views or containers."
+                f"that is not already included in the data model."
+            )
+            return
+        if self._client is None:
+            raise NeatSessionError(
+                "No client provided. You are referencing unknown views and containers in your data model, "
+                "NEAT needs a client to lookup the definitions. "
+                "Please set the client in the session, NeatSession(client=client)."
+            )
+        schema = self._client.schema.retrieve([v.as_id() for v in view_ids], [c.as_id() for c in container_ids])
+        copy_ = rules.model_copy(deep=True)
+        copy_.metadata.version = f"{rules.metadata.version}_completed"
+        importer = DMSImporter(schema)
+        imported = importer.to_rules()
+        if imported.rules is None:
+            self._state.data_model.issue_lists.append(imported.issues)
+            raise NeatSessionError(
+                "Could not import the referenced views and containers. "
+                "See `neat.inspect.issues()` for more information."
+            )
+        verified = VerifyDMSRules("continue", validate=False).transform(imported.rules)
+        if verified.rules is None:
+            self._state.data_model.issue_lists.append(verified.issues)
+            raise NeatSessionError(
+                "Could not verify the referenced views and containers. "
+                "See `neat.inspect.issues()` for more information."
+            )
+        if copy_.containers is None:
+            copy_.containers = verified.rules.containers
+        else:
+            existing_containers = {c.container for c in copy_.containers}
+            copy_.containers.extend(
+                [c for c in verified.rules.containers or [] if c.container not in existing_containers]
+            )
+        existing_views = {v.view for v in copy_.views}
+        copy_.views.extend([v for v in verified.rules.views if v.view not in existing_views])
+        end = datetime.now(timezone.utc)
+
+        change = Change.from_rules_activity(
+            copy_,
+            ProvenanceAgent(id_=DEFAULT_NAMESPACE["agent/"]),
+            start,
+            end,
+            (f"Included referenced views and containers in the data model {rules.metadata.as_data_model_id()}"),
+            self._state.data_model.provenance.source_entity(source_id)
+            or self._state.data_model.provenance.target_entity(source_id),
+        )
+
+        self._state.data_model.write(copy_, change)
+
+        if not use_parent_property_name:
+            return
+
+        source_id, rules = self._state.data_model.last_verified_dms_rules
+        start = datetime.now(timezone.utc)
+        transformer = AsParentPropertyId(self._client)
+        output = transformer.transform(rules)
+        end = datetime.now(timezone.utc)
+
+        change = Change.from_rules_activity(
+            output,
+            transformer.agent,
+            start,
+            end,
+            "Renaming property names to parent name",
+            self._state.data_model.provenance.source_entity(source_id)
+            or self._state.data_model.provenance.target_entity(source_id),
+        )
+
+        self._state.data_model.write(output.rules, change)

cognite/neat/_session/_prepare.py

@@ -8,12 +8,13 @@ from rdflib import URIRef
 
 from cognite.neat._client import NeatClient
 from cognite.neat._constants import DEFAULT_NAMESPACE
-from cognite.neat._graph.transformers import RelationshipToSchemaTransformer
+from cognite.neat._graph.transformers import RelationshipAsEdgeTransformer
 from cognite.neat._graph.transformers._rdfpath import MakeConnectionOnExactMatch
 from cognite.neat._rules._shared import InputRules, ReadRules
 from cognite.neat._rules.importers import DMSImporter
 from cognite.neat._rules.models import DMSRules
 from cognite.neat._rules.models.dms import DMSValidation
+from cognite.neat._rules.models.entities import ClassEntity
 from cognite.neat._rules.models.information._rules_input import InformationInputRules
 from cognite.neat._rules.transformers import (
     PrefixEntities,
@@ -113,20 +114,23 @@ class InstancePrepareAPI:
             raise NeatSessionError(f"Property {property_} is not defined for type {type_}. Cannot make connection")
         return type_uri[0], property_uri[0]
 
-    def relationships_as_connections(self, limit: int = 1) -> None:
+    def relationships_as_edges(self, min_relationship_types: int = 1, limit_per_type: int | None = None) -> None:
         """This assumes that you have read a classic CDF knowledge graph including relationships.
 
-        This transformer analyzes the relationships in the graph and modifies them to be part of the schema
-        for Assets, Events, Files, Sequences, and TimeSeries. Relationships without any properties
-        are replaced by a simple relationship between the source and target nodes. Relationships with
-        properties are replaced by a schema that contains the properties as attributes.
+        This method converts relationships into edges in the graph. This is useful as the
+        edges will be picked up as part of the schema connected to Assets, Events, Files, Sequences,
+        and TimeSeries in the InferenceImporter.
 
         Args:
-            limit: The minimum number of relationships that need to be present for it
-                to be converted into a schema. Default is 1.
+            min_relationship_types: The minimum number of relationship types that must exists to convert those
+                relationships to edges. For example, if there is only 5 relationships between Assets and TimeSeries,
+                and limit is 10, those relationships will not be converted to edges.
+            limit_per_type: The number of conversions to perform per relationship type. For example, if there are 10
+                relationships between Assets and TimeSeries, and limit_per_type is 1, only 1 of those relationships
+                will be converted to an edge. If None, all relationships will be converted.
 
         """
-        transformer = RelationshipToSchemaTransformer(limit=limit)
+        transformer = RelationshipAsEdgeTransformer(min_relationship_types, limit_per_type)
         self._state.instances.store.transform(transformer)
 
 
@@ -463,3 +467,33 @@ class DataModelPrepareAPI:
         )
 
         self._state.data_model.write(copy_, change)
+
+    def add_implements_to_classes(self, suffix: Literal["Edge"], implements: str = "Edge") -> None:
+        """All classes with the suffix will have the implements property set to the given value.
+
+        Args:
+            suffix: The suffix of the classes to add the implements property to.
+            implements:  The value of the implements property to set.
+
+        """
+        source_id, rules = self._state.data_model.last_verified_information_rules
+        start = datetime.now(timezone.utc)
+
+        output = rules.model_copy(deep=True)
+        for class_ in output.classes:
+            if class_.class_.suffix.endswith(suffix):
+                class_.implements = [ClassEntity(prefix=class_.class_.prefix, suffix=implements)]
+        output.metadata.version = f"{rules.metadata.version}.implements_{implements}"
+        end = datetime.now(timezone.utc)
+
+        change = Change.from_rules_activity(
+            output,
+            ProvenanceAgent(id_=DEFAULT_NAMESPACE["agent/"]),
+            start,
+            end,
+            (f"Added implements property to classes with suffix {suffix}"),
+            self._state.data_model.provenance.source_entity(source_id)
+            or self._state.data_model.provenance.target_entity(source_id),
+        )
+
+        self._state.data_model.write(output, change)

cognite/neat/_session/_read.py

@@ -20,7 +20,7 @@ from cognite.neat._store._provenance import Entity as ProvenanceEntity
 from cognite.neat._utils.reader import GitHubReader, NeatReader, PathReader
 
 from ._state import SessionState
-from ._wizard import NeatObjectType, RDFFileType, object_wizard, rdf_dm_wizard
+from ._wizard import NeatObjectType, RDFFileType, XMLFileType, object_wizard, rdf_dm_wizard, xml_format_wizard
 from .engine import import_engine
 from .exceptions import NeatSessionError, session_class_wrapper
 
@@ -35,6 +35,7 @@ class ReadAPI:
         self.excel = ExcelReadAPI(state, client, verbose)
         self.csv = CSVReadAPI(state, client, verbose)
         self.yaml = YamlReadAPI(state, client, verbose)
+        self.xml = XMLReadAPI(state, client, verbose)
 
 
 @session_class_wrapper
@@ -118,7 +119,7 @@ class CDFClassicAPI(BaseReadAPI):
             raise ValueError("No client provided. Please provide a client to read a data model.")
         return self._client
 
-    def graph(self, root_asset_external_id: str) -> None:
+    def graph(self, root_asset_external_id: str, limit_per_type: int | None = None) -> None:
         """Reads the classic knowledge graph from CDF.
 
         The Classic Graph consists of the following core resource type.
@@ -153,9 +154,12 @@ class CDFClassicAPI(BaseReadAPI):
 
         Args:
             root_asset_external_id: The external id of the root asset
+            limit_per_type: The maximum number of nodes to extract per core node type. If None, all nodes are extracted.
 
         """
-        extractor = extractors.ClassicGraphExtractor(self._get_client, root_asset_external_id=root_asset_external_id)
+        extractor = extractors.ClassicGraphExtractor(
+            self._get_client, root_asset_external_id=root_asset_external_id, limit_per_type=limit_per_type
+        )
 
         self._state.instances.store.write(extractor)
         if self._verbose:
@@ -248,7 +252,7 @@ class CSVReadAPI(BaseReadAPI):
         else:
             raise NeatValueError("Only file paths are supported for CSV files")
         engine = import_engine()
-        engine.set.source = ".csv"
+        engine.set.format = "csv"
         engine.set.file = path
         engine.set.type = type
         engine.set.primary_key = primary_key
@@ -257,6 +261,48 @@ class CSVReadAPI(BaseReadAPI):
         self._state.instances.store.write(extractor)
 
 
+@session_class_wrapper
+class XMLReadAPI(BaseReadAPI):
+    def __call__(
+        self,
+        io: Any,
+        format: XMLFileType | None = None,
+    ) -> None:
+        reader = NeatReader.create(io)
+        if isinstance(reader, GitHubReader):
+            path = Path(tempfile.gettempdir()).resolve() / reader.name
+            path.write_text(reader.read_text())
+        elif isinstance(reader, PathReader):
+            path = reader.path
+        else:
+            raise NeatValueError("Only file paths are supported for XML files")
+        if format is None:
+            format = xml_format_wizard()
+
+        if format.lower() == "dexpi":
+            return self.dexpi(path)
+
+        if format.lower() == "aml":
+            return self.aml(path)
+
+        else:
+            raise NeatValueError("Only support XML files of DEXPI format at the moment.")
+
+    def dexpi(self, path):
+        engine = import_engine()
+        engine.set.format = "dexpi"
+        engine.set.file = path
+        extractor = engine.create_extractor()
+        self._state.instances.store.write(extractor)
+
+    def aml(self, path):
+        engine = import_engine()
+        engine.set.format = "aml"
+        engine.set.file = path
+        extractor = engine.create_extractor()
+        self._state.instances.store.write(extractor)
+
+
 @session_class_wrapper
 class RDFReadAPI(BaseReadAPI):
     def __init__(self, state: SessionState, client: NeatClient | None, verbose: bool) -> None:

cognite/neat/_session/_set.py

@@ -29,6 +29,7 @@ class SetAPI:
 
             start = datetime.now(timezone.utc)
             transformer = SetIDDMSModel(new_model_id)
+
             output = transformer.transform(rules)
             end = datetime.now(timezone.utc)