cognite-neat 0.103.0__py3-none-any.whl → 0.104.0__py3-none-any.whl

cognite/neat/_session/_prepare.py

@@ -1,6 +1,4 @@
-import copy
 from collections.abc import Callable, Collection
-from datetime import datetime, timezone
 from typing import Any, Literal, cast
 
 from cognite.client.data_classes.data_modeling import DataModelIdentifier
@@ -8,7 +6,6 @@ from rdflib import URIRef
 
 from cognite.neat._client import NeatClient
 from cognite.neat._constants import (
-    DEFAULT_NAMESPACE,
     get_default_prefixes_and_namespaces,
 )
 from cognite.neat._graph.transformers import (
@@ -22,30 +19,19 @@ from cognite.neat._graph.transformers import (
     Transformers,
 )
 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._issues import IssueList
 from cognite.neat._rules.transformers import (
+    AddClassImplements,
+    IncludeReferenced,
     PrefixEntities,
     ReduceCogniteModel,
     ToCompliantEntities,
     ToExtension,
-    VerifyDMSRules,
 )
-from cognite.neat._store._provenance import Agent as ProvenanceAgent
-from cognite.neat._store._provenance import Change
 
 from ._state import SessionState
 from .exceptions import NeatSessionError, session_class_wrapper
 
-try:
-    from rich import print
-except ImportError:
-    ...
-
 
 @session_class_wrapper
 class PrepareAPI:
@@ -327,53 +313,18 @@ class DataModelPrepareAPI:
         self._state = state
         self._verbose = verbose
 
-    def cdf_compliant_external_ids(self) -> None:
+    def cdf_compliant_external_ids(self) -> IssueList:
         """Convert data model component external ids to CDF compliant entities."""
-        source_id, rules = self._state.data_model.last_info_unverified_rule
-
-        start = datetime.now(timezone.utc)
-        transformer = ToCompliantEntities()
-        output: ReadRules[InformationInputRules] = transformer.transform(rules)
-        end = datetime.now(timezone.utc)
-
-        change = Change.from_rules_activity(
-            output,
-            transformer.agent,
-            start,
-            end,
-            "Converted external ids to CDF compliant entities",
-            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)
+        return self._state.rule_transform(ToCompliantEntities())
 
-    def prefix(self, prefix: str) -> None:
+    def prefix(self, prefix: str) -> IssueList:
         """Prefix all views in the data model with the given prefix.
 
         Args:
             prefix: The prefix to add to the views in the data model.
 
         """
-        source_id, rules = self._state.data_model.last_unverified_rule
-
-        start = datetime.now(timezone.utc)
-        transformer = PrefixEntities(prefix)
-        new_rules = cast(InputRules, copy.deepcopy(rules.get_rules()))
-        output = transformer.transform(new_rules)
-        end = datetime.now(timezone.utc)
-
-        change = Change.from_rules_activity(
-            output,
-            transformer.agent,
-            start,
-            end,
-            "Added prefix to the data model views",
-            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)
+        return self._state.rule_transform(PrefixEntities(prefix))
 
     def to_enterprise(
         self,
@@ -381,7 +332,7 @@ class DataModelPrepareAPI:
         org_name: str = "My",
         dummy_property: str = "GUID",
         move_connections: bool = False,
-    ) -> None:
+    ) -> IssueList:
         """Uses the current data model as a basis to create enterprise data model
 
         Args:
@@ -405,34 +356,15 @@ class DataModelPrepareAPI:
             views as the source and target views.
 
         """
-        if input := self._state.data_model.last_verified_dms_rules:
-            source_id, rules = input
-
-            start = datetime.now(timezone.utc)
-            transformer = ToExtension(
+        return self._state.rule_transform(
+            ToExtension(
                 new_model_id=data_model_id,
                 org_name=org_name,
                 type_="enterprise",
                 dummy_property=dummy_property,
                 move_connections=move_connections,
             )
-            output = transformer.transform(rules)
-            end = datetime.now(timezone.utc)
-
-            change = Change.from_rules_activity(
-                output,
-                transformer.agent,
-                start,
-                end,
-                (
-                    f"Prepared data model {data_model_id} to be enterprise data "
-                    f"model on top of {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(output.rules, change)
+        )
 
     def to_solution(
         self,
@@ -440,7 +372,7 @@ class DataModelPrepareAPI:
         org_name: str = "My",
         mode: Literal["read", "write"] = "read",
         dummy_property: str = "GUID",
-    ) -> None:
+    ) -> IssueList:
         """Uses the current data model as a basis to create solution data model
 
         Args:
@@ -461,34 +393,15 @@ class DataModelPrepareAPI:
             the containers in the solution data model space.
 
         """
-        if input := self._state.data_model.last_verified_dms_rules:
-            source_id, rules = input
-
-            start = datetime.now(timezone.utc)
-            transformer = ToExtension(
+        return self._state.rule_transform(
+            ToExtension(
                 new_model_id=data_model_id,
                 org_name=org_name,
                 type_="solution",
                 mode=mode,
                 dummy_property=dummy_property,
             )
-            output = transformer.transform(rules)
-            end = datetime.now(timezone.utc)
-
-            change = Change.from_rules_activity(
-                output,
-                transformer.agent,
-                start,
-                end,
-                (
-                    f"Prepared data model {data_model_id} to be solution data model "
-                    f"on top of {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(output.rules, change)
+        )
 
     def to_data_product(
         self,
@@ -507,65 +420,25 @@ class DataModelPrepareAPI:
             include: The views to include in the data product data model. Can be either "same-space" or "all".
                 If you set same-space, only the views in the same space as the data model will be included.
         """
-        source_id, rules = self._state.data_model.last_verified_dms_rules
-
-        dms_ref: DMSRules | None = None
-        view_ids, container_ids = DMSValidation(rules, self._client).imported_views_and_containers_ids()
-        if view_ids or container_ids:
-            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])
-
-            importer = DMSImporter(schema)
-            reference_rules = importer.to_rules().rules
-            if reference_rules is not None:
-                imported = VerifyDMSRules("continue").transform(reference_rules)
-                if dms_ref := imported.rules:
-                    rules = rules.model_copy(deep=True)
-                    if rules.containers is None:
-                        rules.containers = dms_ref.containers
-                    else:
-                        existing_containers = {c.container for c in rules.containers}
-                        rules.containers.extend(
-                            [c for c in dms_ref.containers or [] if c.container not in existing_containers]
-                        )
-                    existing_views = {v.view for v in rules.views}
-                    rules.views.extend([v for v in dms_ref.views if v.view not in existing_views])
-                    existing_properties = {(p.view, p.view_property) for p in rules.properties}
-                    rules.properties.extend(
-                        [p for p in dms_ref.properties if (p.view, p.view_property) not in existing_properties]
-                    )
-
-        start = datetime.now(timezone.utc)
-        transformer = ToExtension(
-            new_model_id=data_model_id,
-            org_name=org_name,
-            type_="data_product",
-            include=include,
-        )
-        output = transformer.transform(rules)
-        end = datetime.now(timezone.utc)
-
-        change = Change.from_rules_activity(
-            output,
-            transformer.agent,
-            start,
-            end,
-            (
-                f"Prepared data model {data_model_id} to be data product model "
-                f"on top of {rules.metadata.as_data_model_id()}"
+        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)."
+            )
+        transformers = [
+            IncludeReferenced(self._client, include_properties=True),
+            ToExtension(
+                new_model_id=data_model_id,
+                org_name=org_name,
+                type_="data_product",
+                include=include,
             ),
-            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)
+        self._state.rule_transform(*transformers)
 
-    def reduce(self, drop: Collection[Literal["3D", "Annotation", "BaseViews"] | str]) -> None:
+    def reduce(self, drop: Collection[Literal["3D", "Annotation", "BaseViews"] | str]) -> IssueList:
         """This is a special method that allow you to drop parts of the data model.
         This only applies to Cognite Data Models.
 
@@ -574,90 +447,19 @@ class DataModelPrepareAPI:
                 drops multiple views at once. You can also pass externalIds of views to drop individual views.
 
         """
-        if input := self._state.data_model.last_verified_dms_rules:
-            source_id, rules = input
-            start = datetime.now(timezone.utc)
-
-            transformer = ReduceCogniteModel(drop)
-            output = transformer.transform(rules)
-            output.rules.metadata.version = f"{rules.metadata.version}.reduced"
-
-            end = datetime.now(timezone.utc)
-
-            change = Change.from_rules_activity(
-                output,
-                transformer.agent,
-                start,
-                end,
-                (
-                    f"Reduced data model {rules.metadata.as_data_model_id()}"
-                    f"on top of {rules.metadata.as_data_model_id()}"
-                ),
-                self._state.data_model.provenance.source_entity(source_id),
-            )
+        return self._state.rule_transform(ReduceCogniteModel(drop))
 
-            self._state.data_model.write(output.rules, change)
-
-    def include_referenced(self) -> None:
+    def include_referenced(self) -> IssueList:
         """Include referenced views and containers in the data model."""
-        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)
+        return self._state.rule_transform(IncludeReferenced(self._client))
 
-    def add_implements_to_classes(self, suffix: Literal["Edge"], implements: str = "Edge") -> None:
+    def add_implements_to_classes(self, suffix: Literal["Edge"], implements: str = "Edge") -> IssueList:
         """All classes with the suffix will have the implements property set to the given value.
 
         Args:
@@ -665,24 +467,4 @@ class DataModelPrepareAPI:
             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)
+        return self._state.rule_transform(AddClassImplements(implements, suffix))

cognite/neat/_session/_read.py

@@ -1,5 +1,4 @@
 import tempfile
-from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Literal, cast
 
@@ -12,11 +11,7 @@ from cognite.neat._graph import extractors
 from cognite.neat._issues import IssueList
 from cognite.neat._issues.errors import NeatValueError
 from cognite.neat._rules import catalog, importers
-from cognite.neat._rules._shared import ReadRules
 from cognite.neat._rules.importers import BaseImporter
-from cognite.neat._store._provenance import Activity as ProvenanceActivity
-from cognite.neat._store._provenance import Change
-from cognite.neat._store._provenance import Entity as ProvenanceEntity
 from cognite.neat._utils.reader import GitHubReader, HttpFileReader, NeatReader, PathReader
 
 from ._state import SessionState
@@ -47,26 +42,6 @@ class BaseReadAPI:
         self._verbose = verbose
         self._client = client
 
-    def _store_rules(self, rules: ReadRules, change: Change) -> IssueList:
-        if self._verbose:
-            if rules.issues.has_errors:
-                print("Data model read failed")
-            else:
-                print("Data model read passed")
-
-        if rules.rules:
-            self._state.data_model.write(rules, change)
-
-        return rules.issues
-
-    def _return_filepath(self, io: Any) -> Path:
-        if isinstance(io, str):
-            return Path(io)
-        elif isinstance(io, Path):
-            return io
-        else:
-            raise NeatValueError(f"Expected str or Path, got {type(io)}")
-
 
 @session_class_wrapper
 class CDFReadAPI(BaseReadAPI):
@@ -103,31 +78,8 @@ class CDFReadAPI(BaseReadAPI):
         if not data_model_id.version:
             raise NeatSessionError("Data model version is required to read a data model.")
 
-        # actual reading of data model
-        start = datetime.now(timezone.utc)
         importer = importers.DMSImporter.from_data_model_id(self._get_client, data_model_id)
-        rules = importer.to_rules()
-        end = datetime.now(timezone.utc)
-
-        # provenance information
-        source_entity = ProvenanceEntity.from_data_model_id(data_model_id)
-        agent = importer.agent
-        activity = ProvenanceActivity(
-            was_associated_with=agent,
-            ended_at_time=end,
-            used=source_entity,
-            started_at_time=start,
-        )
-        target_entity = ProvenanceEntity.from_rules(rules, agent, activity)
-        change = Change(
-            source_entity=source_entity,
-            agent=agent,
-            activity=activity,
-            target_entity=target_entity,
-            description=f"DMS Data model {data_model_id.as_tuple()} read as unverified data model",
-        )
-
-        return self._store_rules(rules, change)
+        return self._state.rule_import(importer)
 
 
 @session_class_wrapper
@@ -215,24 +167,9 @@ class ExcelReadAPI(BaseReadAPI):
             io: file path to the Excel sheet
         """
         reader = NeatReader.create(io)
-        start = datetime.now(timezone.utc)
         if not isinstance(reader, PathReader):
             raise NeatValueError("Only file paths are supported for Excel files")
-        importer: importers.ExcelImporter = importers.ExcelImporter(reader.path)
-        input_rules: ReadRules = importer.to_rules()
-        end = datetime.now(timezone.utc)
-
-        if input_rules.rules:
-            change = Change.from_rules_activity(
-                input_rules,
-                importer.agent,
-                start,
-                end,
-                description=f"Excel file {reader!s} read as unverified data model",
-            )
-            self._store_rules(input_rules, change)
-        self._state.data_model.issue_lists.append(input_rules.issues)
-        return input_rules.issues
+        return self._state.rule_import(importers.ExcelImporter(reader.path))
 
 
 @session_class_wrapper
@@ -241,23 +178,9 @@ class ExcelExampleAPI(BaseReadAPI):
 
     @property
     def pump_example(self) -> IssueList:
-        """Reads the Nordic 44 knowledge graph into the NeatSession graph store."""
-        start = datetime.now(timezone.utc)
+        """Reads the Hello World pump example into the NeatSession."""
         importer: importers.ExcelImporter = importers.ExcelImporter(catalog.hello_world_pump)
-        input_rules: ReadRules = importer.to_rules()
-        end = datetime.now(timezone.utc)
-
-        if input_rules.rules:
-            change = Change.from_rules_activity(
-                input_rules,
-                importer.agent,
-                start,
-                end,
-                description="Pump Example read as unverified data model",
-            )
-            self._store_rules(input_rules, change)
-        self._state.data_model.issue_lists.append(input_rules.issues)
-        return input_rules.issues
+        return self._state.rule_import(importer)
 
 
 @session_class_wrapper
@@ -278,10 +201,9 @@ class YamlReadAPI(BaseReadAPI):
         reader = NeatReader.create(io)
         if not isinstance(reader, PathReader):
             raise NeatValueError("Only file paths are supported for YAML files")
-        start = datetime.now(timezone.utc)
         importer: BaseImporter
         if format == "neat":
-            importer = importers.YAMLImporter.from_file(reader.path)
+            importer = importers.YAMLImporter.from_file(reader.path, source_name=f"{reader!s}")
         elif format == "toolkit":
             if reader.path.is_file():
                 dms_importer = importers.DMSImporter.from_zip_file(reader.path)
@@ -289,6 +211,7 @@ class YamlReadAPI(BaseReadAPI):
                 dms_importer = importers.DMSImporter.from_directory(reader.path)
             else:
                 raise NeatValueError(f"Unsupported YAML format: {format}")
+
             ref_containers = dms_importer.root_schema.referenced_container()
             if system_container_ids := [
                 container_id for container_id in ref_containers if container_id.space in COGNITE_SPACES
@@ -305,21 +228,7 @@ class YamlReadAPI(BaseReadAPI):
             importer = dms_importer
         else:
             raise NeatValueError(f"Unsupported YAML format: {format}")
-        input_rules: ReadRules = importer.to_rules()
-
-        end = datetime.now(timezone.utc)
-
-        if input_rules.rules:
-            change = Change.from_rules_activity(
-                input_rules,
-                importer.agent,
-                start,
-                end,
-                description=f"YAML file {reader!s} read as unverified data model",
-            )
-            self._store_rules(input_rules, change)
-
-        return input_rules.issues
+        return self._state.rule_import(importer)
 
 
 @session_class_wrapper
@@ -452,25 +361,11 @@ class RDFReadAPI(BaseReadAPI):
             neat.read.rdf.ontology("url_or_path_to_owl_source")
             ```
         """
-        start = datetime.now(timezone.utc)
         reader = NeatReader.create(io)
         if not isinstance(reader, PathReader):
             raise NeatValueError("Only file paths are supported for RDF files")
-        importer = importers.OWLImporter.from_file(reader.path)
-        input_rules: ReadRules = importer.to_rules()
-        end = datetime.now(timezone.utc)
-
-        if input_rules.rules:
-            change = Change.from_rules_activity(
-                input_rules,
-                importer.agent,
-                start,
-                end,
-                description=f"Ontology file {reader!s} read as unverified data model",
-            )
-            self._store_rules(input_rules, change)
-
-        return input_rules.issues
+        importer = importers.OWLImporter.from_file(reader.path, source_name=f"file {reader!s}")
+        return self._state.rule_import(importer)
 
     def imf(self, io: Any) -> IssueList:
         """Reads IMF Types provided as SHACL shapes into NeatSession.
@@ -483,25 +378,11 @@ class RDFReadAPI(BaseReadAPI):
             neat.read.rdf.imf("url_or_path_to_imf_source")
             ```
         """
-        start = datetime.now(timezone.utc)
         reader = NeatReader.create(io)
         if not isinstance(reader, PathReader):
             raise NeatValueError("Only file paths are supported for RDF files")
-        importer = importers.IMFImporter.from_file(reader.path)
-        input_rules: ReadRules = importer.to_rules()
-        end = datetime.now(timezone.utc)
-
-        if input_rules.rules:
-            change = Change.from_rules_activity(
-                input_rules,
-                importer.agent,
-                start,
-                end,
-                description=f"IMF Types file {reader!s} read as unverified data model",
-            )
-            self._store_rules(input_rules, change)
-
-        return input_rules.issues
+        importer = importers.IMFImporter.from_file(reader.path, source_name=f"file {reader!s}")
+        return self._state.rule_import(importer)
 
     def __call__(
         self,

cognite/neat/_session/_set.py

@@ -1,10 +1,9 @@
-from datetime import datetime, timezone
-
 from cognite.client import data_modeling as dm
 
 from cognite.neat._constants import COGNITE_MODELS
+from cognite.neat._issues import IssueList
+from cognite.neat._rules.models import DMSRules
 from cognite.neat._rules.transformers import SetIDDMSModel
-from cognite.neat._store._provenance import Change
 
 from ._state import SessionState
 from .exceptions import NeatSessionError, session_class_wrapper
@@ -18,7 +17,7 @@ class SetAPI:
         self._state = state
         self._verbose = verbose
 
-    def data_model_id(self, new_model_id: dm.DataModelId | tuple[str, str, str]) -> None:
+    def data_model_id(self, new_model_id: dm.DataModelId | tuple[str, str, str]) -> IssueList:
         """Sets the data model ID of the latest verified data model. Set the data model id as a tuple of strings
         following the template (<data_model_space>, <data_model_name>, <data_model_version>).
 
@@ -28,34 +27,11 @@ class SetAPI:
             neat.set.data_model_id(("my_data_model_space", "My_Data_Model", "v1"))
             ```
         """
-        if res := self._state.data_model.last_verified_dms_rules:
-            source_id, rules = res
-
+        rules = self._state.rule_store.get_last_successful_entity().result
+        if isinstance(rules, DMSRules):
             if rules.metadata.as_data_model_id() in COGNITE_MODELS:
                 raise NeatSessionError(
                     "Cannot change the data model ID of a Cognite Data Model in NeatSession"
                     " due to temporarily issue with the reverse direct relation interpretation"
                 )
-
-            start = datetime.now(timezone.utc)
-            transformer = SetIDDMSModel(new_model_id)
-
-            output = transformer.transform(rules)
-            end = datetime.now(timezone.utc)
-
-            # Provenance
-            change = Change.from_rules_activity(
-                output.rules,
-                transformer.agent,
-                start,
-                end,
-                "Changed 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(output.rules, change)
-            if self._verbose:
-                print(f"Data model ID set to {new_model_id}")
-        else:
-            print("No verified DMS data model available")
+        return self._state.rule_transform(SetIDDMSModel(new_model_id))