cognite-neat 0.96.5__py3-none-any.whl → 0.97.0__py3-none-any.whl

cognite/neat/_rules/models/dms/_exporter.py

@@ -402,17 +402,30 @@ class _DMSExporter:
 
         return container_properties_by_id, view_properties_by_id
 
-    @staticmethod
     def _gather_properties_with_ancestors(
+        self,
         view_properties_by_id: dict[dm.ViewId, list[DMSProperty]],
         views: Sequence[DMSView],
     ) -> dict[dm.ViewId, list[DMSProperty]]:
+        all_view_properties_by_id = view_properties_by_id.copy()
+        if self.rules.reference:
+            # We need to include t
+            ref_view_properties_by_id = self._gather_properties(self.rules.reference.properties)[1]
+            for view_id, properties in ref_view_properties_by_id.items():
+                if view_id not in all_view_properties_by_id:
+                    all_view_properties_by_id[view_id] = properties
+                else:
+                    existing_properties = {prop._identifier() for prop in all_view_properties_by_id[view_id]}
+                    for prop in properties:
+                        if prop._identifier() not in existing_properties:
+                            all_view_properties_by_id[view_id].append(prop)
+
         view_properties_with_parents_by_id: dict[dm.ViewId, list[DMSProperty]] = defaultdict(list)
         view_by_view_id = {view.view.as_id(): view for view in views}
         for view in views:
             view_id = view.view.as_id()
             seen: set[Hashable] = set()
-            if view_properties := view_properties_by_id.get(view_id):
+            if view_properties := all_view_properties_by_id.get(view_id):
                 view_properties_with_parents_by_id[view_id].extend(view_properties)
                 seen.update(prop._identifier() for prop in view_properties)
             if not view.implements:
@@ -428,7 +441,7 @@ class _DMSExporter:
                             parents.append(grandparent)
                             seen_parents.add(grandparent)
 
-                if not (parent_view_properties := view_properties_by_id.get(parent_view_id)):
+                if not (parent_view_properties := all_view_properties_by_id.get(parent_view_id)):
                     continue
                 for prop in parent_view_properties:
                     new_prop = prop.model_copy(update={"view": view.view})

cognite/neat/_rules/models/dms/_rules.py

@@ -1,15 +1,16 @@
 import math
-import sys
 import warnings
 from collections.abc import Hashable
 from datetime import datetime
-from typing import TYPE_CHECKING, Any, ClassVar, Literal
+from typing import Any, ClassVar, Literal
 
 import pandas as pd
 from cognite.client import data_modeling as dm
 from pydantic import Field, field_serializer, field_validator, model_validator
 from pydantic_core.core_schema import SerializationInfo, ValidationInfo
+from rdflib import URIRef
 
+from cognite.neat._constants import COGNITE_SPACES, DEFAULT_NAMESPACE
 from cognite.neat._issues import MultiValueError
 from cognite.neat._issues.warnings import (
     PrincipleMatchingSpaceAndVersionWarning,
@@ -56,14 +57,6 @@ from cognite.neat._rules.models.entities import (
 
 from ._schema import DMSSchema
 
-if TYPE_CHECKING:
-    pass
-
-if sys.version_info >= (3, 11):
-    pass
-else:
-    pass
-
 _DEFAULT_VERSION = "1"
 
 
@@ -197,6 +190,24 @@ class DMSProperty(SheetRow):
             raise ValueError(f"Reverse connection must have a value type that points to a view, got {value}")
         return value
 
+    @field_validator("container", "container_property", mode="after")
+    def container_set_correctly(cls, value: Any, info: ValidationInfo) -> Any:
+        if (connection := info.data.get("connection")) is None:
+            return value
+        if connection == "direct" and value is None:
+            raise ValueError(
+                "You must provide a container and container property for where to store direct connections"
+            )
+        elif isinstance(connection, EdgeEntity) and value is not None:
+            raise ValueError(
+                "Edge connections are not stored in a container, please remove the container and container property"
+            )
+        elif isinstance(connection, ReverseConnectionEntity) and value is not None:
+            raise ValueError(
+                "Reverse connection are not stored in a container, please remove the container and container property"
+            )
+        return value
+
     @field_serializer("reference", when_used="always")
     def set_reference(self, value: Any, info: SerializationInfo) -> str | None:
         if isinstance(info.context, dict) and info.context.get("as_reference") is True:
@@ -421,7 +432,11 @@ class DMSRules(BaseRules):
         if not (metadata := info.data.get("metadata")):
             return value
         model_version = metadata.version
-        if different_version := [view.view.as_id() for view in value if view.view.version != model_version]:
+        if different_version := [
+            view.view.as_id()
+            for view in value
+            if view.view.version != model_version and view.view.space not in COGNITE_SPACES
+        ]:
             for view_id in different_version:
                 warnings.warn(
                     PrincipleMatchingSpaceAndVersionWarning(
@@ -429,7 +444,11 @@ class DMSRules(BaseRules):
                     ),
                     stacklevel=2,
                 )
-        if different_space := [view.view.as_id() for view in value if view.view.space != metadata.space]:
+        if different_space := [
+            view.view.as_id()
+            for view in value
+            if view.view.space != metadata.space and view.view.space not in COGNITE_SPACES
+        ]:
             for view_id in different_space:
                 warnings.warn(
                     PrincipleMatchingSpaceAndVersionWarning(
@@ -469,3 +488,9 @@ class DMSRules(BaseRules):
         }
 
         return pd.DataFrame([summary]).T.rename(columns={0: ""})._repr_html_()  # type: ignore
+
+    @property
+    def id_(self) -> URIRef:
+        return DEFAULT_NAMESPACE[
+            f"data-model/verified/dms/{self.metadata.space}/{self.metadata.external_id}/{self.metadata.version}"
+        ]

cognite/neat/_rules/models/dms/_rules_input.py

@@ -5,7 +5,9 @@ from typing import Any, Literal
 
 import pandas as pd
 from cognite.client import data_modeling as dm
+from rdflib import URIRef
 
+from cognite.neat._constants import DEFAULT_NAMESPACE
 from cognite.neat._rules.models._base_input import InputComponent, InputRules
 from cognite.neat._rules.models.data_types import DataType
 from cognite.neat._rules.models.entities import (
@@ -307,3 +309,9 @@ class DMSInputRules(InputRules[DMSRules]):
         }
 
         return pd.DataFrame([summary]).T.rename(columns={0: ""})._repr_html_()  # type: ignore
+
+    @property
+    def id_(self) -> URIRef:
+        return DEFAULT_NAMESPACE[
+            f"data-model/unverified/dms/{self.metadata.space}/{self.metadata.external_id}/{self.metadata.version}"
+        ]

cognite/neat/_rules/models/dms/_validation.py

@@ -1,18 +1,20 @@
 from collections import defaultdict
-from typing import Any, ClassVar
+from typing import Any, ClassVar, cast
 
 from cognite.client import data_modeling as dm
 
-from cognite.neat._constants import DMS_CONTAINER_PROPERTY_SIZE_LIMIT
+from cognite.neat._constants import COGNITE_MODELS, DMS_CONTAINER_PROPERTY_SIZE_LIMIT
 from cognite.neat._issues import IssueList, NeatError, NeatIssue, NeatIssueList
 from cognite.neat._issues.errors import (
     PropertyDefinitionDuplicatedError,
     ResourceChangedError,
     ResourceNotDefinedError,
 )
+from cognite.neat._issues.errors._properties import ReversedConnectionNotFeasibleError
 from cognite.neat._issues.warnings import (
     NotSupportedHasDataFilterLimitWarning,
     NotSupportedViewContainerLimitWarning,
+    UndefinedViewWarning,
 )
 from cognite.neat._issues.warnings.user_modeling import (
     NotNeatSupportedFilterWarning,
@@ -21,6 +23,10 @@ from cognite.neat._issues.warnings.user_modeling import (
 from cognite.neat._rules.models._base_rules import DataModelType, ExtensionCategory, SchemaCompleteness
 from cognite.neat._rules.models.data_types import DataType
 from cognite.neat._rules.models.entities import ContainerEntity, RawFilter
+from cognite.neat._rules.models.entities._single_value import (
+    ReverseConnectionEntity,
+    ViewEntity,
+)
 
 from ._rules import DMSProperty, DMSRules
 from ._schema import DMSSchema
@@ -45,6 +51,8 @@ class DMSPostValidation:
     def validate(self) -> NeatIssueList:
         self._validate_raw_filter()
         self._consistent_container_properties()
+        self._validate_value_type_existence()
+        self._validate_reverse_connections()
 
         self._referenced_views_and_containers_are_existing_and_proper_size()
         if self.metadata.schema_ is SchemaCompleteness.extended:
@@ -318,6 +326,60 @@ class DMSPostValidation:
                     NotNeatSupportedFilterWarning(view.view.as_id()),
                 )
 
+    def _validate_value_type_existence(self) -> None:
+        views = {prop_.view for prop_ in self.properties}.union({view_.view for view_ in self.views})
+
+        for prop_ in self.properties:
+            if isinstance(prop_.value_type, ViewEntity) and prop_.value_type not in views:
+                self.issue_list.append(
+                    UndefinedViewWarning(
+                        str(prop_.view),
+                        str(prop_.value_type),
+                        prop_.property_,
+                    )
+                )
+
+    def _validate_reverse_connections(self) -> None:
+        # do not check for reverse connections in Cognite models
+        if self.metadata.as_data_model_id() in COGNITE_MODELS:
+            return None
+
+        properties_by_ids = {f"{prop_.view!s}.{prop_.property_}": prop_ for prop_ in self.properties}
+        reversed_by_ids = {
+            id_: prop_
+            for id_, prop_ in properties_by_ids.items()
+            if prop_.connection and isinstance(prop_.connection, ReverseConnectionEntity)
+        }
+
+        for id_, prop_ in reversed_by_ids.items():
+            source_id = f"{prop_.value_type!s}." f"{cast(ReverseConnectionEntity, prop_.connection).property_}"
+            if source_id not in properties_by_ids:
+                self.issue_list.append(
+                    ReversedConnectionNotFeasibleError(
+                        id_,
+                        "reversed connection",
+                        prop_.property_,
+                        str(prop_.view),
+                        str(prop_.value_type),
+                        cast(ReverseConnectionEntity, prop_.connection).property_,
+                    )
+                )
+
+            elif source_id in properties_by_ids and properties_by_ids[source_id].value_type != prop_.view:
+                self.issue_list.append(
+                    ReversedConnectionNotFeasibleError(
+                        id_,
+                        "view property",
+                        prop_.property_,
+                        str(prop_.view),
+                        str(prop_.value_type),
+                        cast(ReverseConnectionEntity, prop_.connection).property_,
+                    )
+                )
+
+            else:
+                continue
+
     @staticmethod
     def _changed_attributes_and_properties(
         new_dumped: dict[str, Any], existing_dumped: dict[str, Any]

cognite/neat/_rules/models/domain.py

@@ -4,7 +4,9 @@ from dataclasses import dataclass, field
 from typing import ClassVar
 
 from pydantic import Field, field_serializer, field_validator
+from rdflib import URIRef
 
+from cognite.neat._constants import DEFAULT_NAMESPACE
 from cognite.neat._rules.models.data_types import DataType
 from cognite.neat._rules.models.entities import ClassEntity, ClassEntityList
 
@@ -76,6 +78,10 @@ class DomainRules(BaseRules):
     last: "DomainRules | None" = Field(None, alias="Last")
     reference: "DomainRules | None" = Field(None, alias="Reference")
 
+    @property
+    def id_(self) -> URIRef:
+        return DEFAULT_NAMESPACE["data-model/verified/domain"]
+
 
 @dataclass
 class DomainInputMetadata(InputComponent[DomainMetadata]):
@@ -124,3 +130,7 @@ class DomainInputRules(InputRules[DomainRules]):
     @classmethod
     def _get_verified_cls(cls) -> type[DomainRules]:
         return DomainRules
+
+    @property
+    def id_(self) -> URIRef:
+        return DEFAULT_NAMESPACE["data-model/unverified/domain"]

cognite/neat/_rules/models/entities/_loaders.py

@@ -63,11 +63,9 @@ def load_connection(
     default_space: str,
     default_version: str,
 ) -> Literal["direct"] | ReverseConnectionEntity | EdgeEntity | None:
-    if (
-        isinstance(raw, EdgeEntity | ReverseConnectionEntity)
-        or raw is None
-        or (isinstance(raw, str) and raw == "direct")
-    ):
+    if isinstance(raw, str) and raw.lower() == "direct":
+        return "direct"  # type: ignore[return-value]
+    elif isinstance(raw, EdgeEntity | ReverseConnectionEntity) or raw is None:
         return raw  # type: ignore[return-value]
     elif isinstance(raw, str) and raw.startswith("edge"):
         return EdgeEntity.load(raw, space=default_space, version=default_version)  # type: ignore[return-value]

cognite/neat/_rules/models/information/_rules.py

@@ -7,9 +7,9 @@ from typing import TYPE_CHECKING, Any, ClassVar
 import pandas as pd
 from pydantic import Field, field_serializer, field_validator, model_validator
 from pydantic_core.core_schema import SerializationInfo
-from rdflib import Namespace
+from rdflib import Namespace, URIRef
 
-from cognite.neat._constants import get_default_prefixes
+from cognite.neat._constants import DEFAULT_NAMESPACE, get_default_prefixes
 from cognite.neat._issues.errors import NeatValueError, PropertyDefinitionError
 from cognite.neat._rules._constants import EntityTypes
 from cognite.neat._rules.models._base_rules import (
@@ -394,3 +394,7 @@ class InformationRules(BaseRules):
         }
 
         return pd.DataFrame([summary]).T.rename(columns={0: ""})._repr_html_()  # type: ignore
+
+    @property
+    def id_(self) -> URIRef:
+        return DEFAULT_NAMESPACE[f"data-model/verified/info/{self.metadata.prefix}/{self.metadata.version}"]

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

@@ -3,8 +3,9 @@ from datetime import datetime
 from typing import Any, Literal
 
 import pandas as pd
-from rdflib import Namespace
+from rdflib import Namespace, URIRef
 
+from cognite.neat._constants import DEFAULT_NAMESPACE
 from cognite.neat._rules.models._base_input import InputComponent, InputRules
 from cognite.neat._rules.models.data_types import DataType
 from cognite.neat._rules.models.entities import (
@@ -158,3 +159,7 @@ class InformationInputRules(InputRules[InformationRules]):
         }
 
         return pd.DataFrame([summary]).T.rename(columns={0: ""})._repr_html_()  # type: ignore
+
+    @property
+    def id_(self) -> URIRef:
+        return DEFAULT_NAMESPACE[f"data-model/unverified/info/{self.metadata.prefix}/{self.metadata.version}"]

cognite/neat/_rules/transformers/_base.py

@@ -2,6 +2,7 @@ from abc import ABC, abstractmethod
 from collections.abc import MutableSequence
 from typing import Generic, TypeVar
 
+from cognite.neat._constants import DEFAULT_NAMESPACE
 from cognite.neat._issues import IssueList, NeatError
 from cognite.neat._issues.errors import NeatTypeError, NeatValueError
 from cognite.neat._rules._shared import (
@@ -12,6 +13,7 @@ from cognite.neat._rules._shared import (
     Rules,
     VerifiedRules,
 )
+from cognite.neat._store._provenance import Agent as ProvenanceAgent
 
 T_RulesIn = TypeVar("T_RulesIn", bound=Rules)
 T_RulesOut = TypeVar("T_RulesOut", bound=Rules)
@@ -54,6 +56,11 @@ class RulesTransformer(ABC, Generic[T_RulesIn, T_RulesOut]):
         else:
             raise NeatTypeError(f"Unsupported type: {type(rules)}")
 
+    @property
+    def agent(self) -> ProvenanceAgent:
+        """Provenance agent for the importer."""
+        return ProvenanceAgent(id_=DEFAULT_NAMESPACE[f"agent/{type(self).__name__}"])
+
 
 class RulesPipeline(list, MutableSequence[RulesTransformer], Generic[T_RulesIn, T_RulesOut]):
     def transform(self, rules: T_RulesIn | OutRules[T_RulesIn]) -> OutRules[T_RulesOut]:

cognite/neat/_rules/transformers/_converters.py

@@ -10,7 +10,11 @@ from cognite.client.data_classes import data_modeling as dms
 from cognite.client.data_classes.data_modeling import DataModelId, DataModelIdentifier, ViewId
 from rdflib import Namespace
 
-from cognite.neat._constants import COGNITE_MODELS, DMS_CONTAINER_PROPERTY_SIZE_LIMIT
+from cognite.neat._constants import (
+    COGNITE_MODELS,
+    DMS_CONTAINER_PROPERTY_SIZE_LIMIT,
+)
+from cognite.neat._issues._base import IssueList
 from cognite.neat._issues.errors import NeatValueError
 from cognite.neat._issues.warnings._models import (
     EnterpriseModelNotBuildOnTopOfCDMWarning,
@@ -18,7 +22,13 @@ from cognite.neat._issues.warnings._models import (
 )
 from cognite.neat._issues.warnings.user_modeling import ParentInDifferentSpaceWarning
 from cognite.neat._rules._constants import EntityTypes
-from cognite.neat._rules._shared import InputRules, JustRules, OutRules, VerifiedRules
+from cognite.neat._rules._shared import (
+    InputRules,
+    JustRules,
+    OutRules,
+    ReadRules,
+    VerifiedRules,
+)
 from cognite.neat._rules.analysis import DMSAnalysis
 from cognite.neat._rules.models import (
     AssetRules,
@@ -83,13 +93,16 @@ class ToCompliantEntities(RulesTransformer[InformationInputRules, InformationInp
 
     def transform(
         self, rules: InformationInputRules | OutRules[InformationInputRules]
-    ) -> OutRules[InformationInputRules]:
-        return JustRules(self._transform(self._to_rules(rules)))
+    ) -> ReadRules[InformationInputRules]:
+        return ReadRules(self._transform(self._to_rules(rules)), IssueList(), {})
 
     def _transform(self, rules: InformationInputRules) -> InformationInputRules:
         rules.metadata.prefix = self._fix_entity(rules.metadata.prefix)
         rules.classes = self._fix_classes(rules.classes)
         rules.properties = self._fix_properties(rules.properties)
+
+        rules.metadata.version += "_dms_compliant"
+
         return rules
 
     @classmethod
@@ -258,6 +271,7 @@ class ToExtension(RulesTransformer[DMSRules, DMSRules]):
         type_: Literal["enterprise", "solution"] = "enterprise",
         mode: Literal["read", "write"] = "read",
         dummy_property: str = "GUID",
+        move_connections: bool = False,
     ):
         self.new_model_id = DataModelId.load(new_model_id)
         if not self.new_model_id.version:
@@ -267,6 +281,7 @@ class ToExtension(RulesTransformer[DMSRules, DMSRules]):
         self.mode = mode
         self.type_ = type_
         self.dummy_property = dummy_property
+        self.move_connections = move_connections
 
     def transform(self, rules: DMSRules | OutRules[DMSRules]) -> JustRules[DMSRules]:
         # Copy to ensure immutability
@@ -393,10 +408,18 @@ class ToExtension(RulesTransformer[DMSRules, DMSRules]):
         # extending reference views with new ones
         enterprise_model.views.extend(enterprise_views)
 
+        # Move connections from reference model to enterprise model
+        if self.move_connections:
+            enterprise_connections = self._move_connections(enterprise_model)
+        else:
+            enterprise_connections = SheetList[DMSProperty]()
+
         # while overwriting containers and properties with new ones
         enterprise_model.containers = enterprise_containers
         enterprise_model.properties = enterprise_properties
 
+        enterprise_properties.extend(enterprise_connections)
+
         return JustRules(enterprise_model)
 
     def _remove_cognite_affix(self, entity: _T_Entity) -> _T_Entity:
@@ -455,6 +478,35 @@ class ToExtension(RulesTransformer[DMSRules, DMSRules]):
 
         return new_views, new_containers, new_properties
 
+    def _move_connections(self, rules: DMSRules) -> SheetList[DMSProperty]:
+        implements: dict[ViewEntity, list[ViewEntity]] = defaultdict(list)
+        new_properties = SheetList[DMSProperty]()
+
+        for view in rules.views:
+            if view.view.space == rules.metadata.space and view.implements:
+                for implemented_view in view.implements:
+                    implements.setdefault(implemented_view, []).append(view.view)
+
+        # currently only supporting single implementation of reference view in enterprise view
+        # connections that do not have properties
+        if all(len(v) == 1 for v in implements.values()):
+            for prop_ in rules.properties:
+                if (
+                    prop_.view.space != rules.metadata.space
+                    and prop_.connection
+                    and isinstance(prop_.value_type, ViewEntity)
+                    and implements.get(prop_.view)
+                    and implements.get(prop_.value_type)
+                ):
+                    if isinstance(prop_.connection, EdgeEntity) and prop_.connection.properties:
+                        continue
+                    new_property = prop_.model_copy(deep=True)
+                    new_property.view = implements[prop_.view][0]
+                    new_property.value_type = implements[prop_.value_type][0]
+                    new_properties.append(new_property)
+
+        return new_properties
+
 
 class ReduceCogniteModel(RulesTransformer[DMSRules, DMSRules]):
     _ASSET_VIEW = ViewId("cdf_cdm", "CogniteAsset", "v1")

cognite/neat/_session/_base.py

@@ -1,3 +1,4 @@
+from datetime import datetime, timezone
 from typing import Literal, cast
 
 from cognite.client import CogniteClient
@@ -14,6 +15,10 @@ from cognite.neat._rules.models.entities._single_value import UnknownEntity
 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._store._provenance import (
+    INSTANCES_ENTITY,
+    Change,
+)
 
 from ._inspect import InspectAPI
 from ._prepare import PrepareAPI
@@ -22,7 +27,8 @@ from ._set import SetAPI
 from ._show import ShowAPI
 from ._state import SessionState
 from ._to import ToAPI
-from .exceptions import intercept_session_exceptions
+from .engine import load_neat_engine
+from .exceptions import NeatSessionError, intercept_session_exceptions
 
 
 @intercept_session_exceptions
@@ -32,6 +38,7 @@ class NeatSession:
         client: CogniteClient | None = None,
         storage: Literal["memory", "oxigraph"] = "memory",
         verbose: bool = True,
+        load_engine: Literal["newest", "cache", "skip"] = "cache",
     ) -> None:
         self._client = client
         self._verbose = verbose
@@ -42,26 +49,69 @@ class NeatSession:
         self.show = ShowAPI(self._state)
         self.set = SetAPI(self._state, verbose)
         self.inspect = InspectAPI(self._state)
+        if load_engine != "skip" and (engine_version := load_neat_engine(client, load_engine)):
+            print(f"Neat Engine {engine_version} loaded.")
 
     @property
     def version(self) -> str:
         return _version.__version__
 
     def verify(self) -> IssueList:
-        output = VerifyAnyRules("continue").try_transform(self._state.input_rule)
+        source_id, last_unverified_rule = self._state.data_model.last_unverified_rule
+        transformer = VerifyAnyRules("continue")
+        start = datetime.now(timezone.utc)
+        output = transformer.try_transform(last_unverified_rule)
+        end = datetime.now(timezone.utc)
+
         if output.rules:
-            self._state.verified_rules.append(output.rules)
+            change = Change.from_rules_activity(
+                output.rules,
+                transformer.agent,
+                start,
+                end,
+                f"Verified data model {source_id} as {output.rules.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 isinstance(output.rules, InformationRules):
-                self._state.store.add_rules(output.rules)
+                self._state.instances.store.add_rules(output.rules)
+
         output.issues.action = "verify"
-        self._state.issue_lists.append(output.issues)
+        self._state.data_model.issue_lists.append(output.issues)
         if output.issues:
             print("You can inspect the issues with the .inspect.issues(...) method.")
         return output.issues
 
-    def convert(self, target: Literal["dms"]) -> None:
-        converted = ConvertToRules(DMSRules).transform(self._state.last_verified_rule)
-        self._state.verified_rules.append(converted.rules)
+    def convert(self, target: Literal["dms", "information"]) -> None:
+        start = datetime.now(timezone.utc)
+        if target == "dms":
+            source_id, info_rules = self._state.data_model.last_verified_information_rules
+            converter = ConvertToRules(DMSRules)
+            converted_rules = converter.transform(info_rules).rules
+        elif target == "information":
+            source_id, dms_rules = self._state.data_model.last_verified_dms_rules
+            converter = ConvertToRules(InformationRules)
+            converted_rules = converter.transform(dms_rules).rules
+        else:
+            raise NeatSessionError(f"Target {target} not supported.")
+        end = datetime.now(timezone.utc)
+
+        # Provenance
+        change = Change.from_rules_activity(
+            converted_rules,
+            converter.agent,
+            start,
+            end,
+            f"Converted data model {source_id} to {converted_rules.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(converted_rules, change)
+
         if self._verbose:
             print(f"Rules converted to {target}")
 
@@ -73,6 +123,7 @@ class NeatSession:
             "v1",
         ),
         non_existing_node_type: UnknownEntity | AnyURI = DEFAULT_NON_EXISTING_NODE_TYPE,
+        max_number_of_instance: int = 100,
     ) -> IssueList:
         """Data model inference from instances.
 
@@ -83,35 +134,55 @@ class NeatSession:
 
         model_id = dm.DataModelId.load(model_id)
 
-        input_rules: ReadRules = importers.InferenceImporter.from_graph_store(
-            store=self._state.store,
+        start = datetime.now(timezone.utc)
+        importer = importers.InferenceImporter.from_graph_store(
+            store=self._state.instances.store,
             non_existing_node_type=non_existing_node_type,
-        ).to_rules()
+            max_number_of_instance=max_number_of_instance,
+        )
+        inferred_rules: ReadRules = importer.to_rules()
+        end = datetime.now(timezone.utc)
 
         if model_id.space:
-            cast(InformationInputRules, input_rules.rules).metadata.prefix = model_id.space
+            cast(InformationInputRules, inferred_rules.rules).metadata.prefix = model_id.space
         if model_id.external_id:
-            cast(InformationInputRules, input_rules.rules).metadata.name = model_id.external_id
+            cast(InformationInputRules, inferred_rules.rules).metadata.name = model_id.external_id
 
         if model_id.version:
-            cast(InformationInputRules, input_rules.rules).metadata.version = model_id.version
+            cast(InformationInputRules, inferred_rules.rules).metadata.version = model_id.version
+
+        # Provenance
+        change = Change.from_rules_activity(
+            inferred_rules,
+            importer.agent,
+            start,
+            end,
+            "Inferred data model",
+            INSTANCES_ENTITY,
+        )
 
-        self.read.rdf._store_rules(self._state.store, input_rules, "Data Model Inference")
-        return input_rules.issues
+        self._state.data_model.write(inferred_rules, change)
+        return inferred_rules.issues
 
     def _repr_html_(self) -> str:
         state = self._state
-        if not state.has_store and not state.input_rules:
+        if (
+            not state.instances.has_store
+            and not state.data_model.has_unverified_rules
+            and not state.data_model.has_verified_rules
+        ):
             return "<strong>Empty session</strong>. Get started by reading something with the <em>.read</em> attribute."
 
         output = []
-        if state.input_rules and not state.verified_rules:
-            output.append(f"<H2>Unverified Data Model</H2><br />{state.input_rule.rules._repr_html_()}")  # type: ignore
 
-        if state.verified_rules:
-            output.append(f"<H2>Verified Data Model</H2><br />{state.last_verified_rule._repr_html_()}")  # type: ignore
+        if state.data_model.has_unverified_rules and not state.data_model.has_verified_rules:
+            rules: ReadRules = state.data_model.last_unverified_rule[1]
+            output.append(f"<H2>Unverified Data Model</H2><br />{rules.rules._repr_html_()}")  # type: ignore
+
+        if state.data_model.has_verified_rules:
+            output.append(f"<H2>Verified Data Model</H2><br />{state.data_model.last_verified_rule[1]._repr_html_()}")  # type: ignore
 
-        if state.has_store:
-            output.append(f"<H2>Instances</H2> {state.store._repr_html_()}")
+        if state.instances.has_store:
+            output.append(f"<H2>Instances</H2> {state.instances.store._repr_html_()}")
 
         return "<br />".join(output)