cognite-neat 0.121.1__py3-none-any.whl → 0.122.0__py3-none-any.whl

cognite/neat/session/_base.py

@@ -7,21 +7,21 @@ from cognite.client import data_modeling as dm
 from cognite.neat import _version
 from cognite.neat.core._client import NeatClient
 from cognite.neat.core._data_model import importers
-from cognite.neat.core._data_model.models import DMSRules
+from cognite.neat.core._data_model.models import PhysicalDataModel
 from cognite.neat.core._data_model.models.conceptual._verified import (
     ConceptualDataModel,
 )
 from cognite.neat.core._data_model.transformers import (
-    InformationToDMS,
-    MergeDMSRules,
-    MergeInformationRules,
+    ConceptualToPhysical,
+    MergeConceptualDataModels,
+    MergePhysicalDataModels,
     ToDMSCompliantEntities,
-    VerifyInformationRules,
+    VerifyConceptualDataModel,
 )
 from cognite.neat.core._issues import IssueList
 from cognite.neat.core._issues.errors import RegexViolationError
 from cognite.neat.core._issues.errors._general import NeatImportError
-from cognite.neat.core._store._rules_store import RulesEntity
+from cognite.neat.core._store._data_model import DataModelEntity
 from cognite.neat.core._utils.auxiliary import local_import
 
 from ._collector import _COLLECTOR, Collector
@@ -162,20 +162,22 @@ class NeatSession:
             reserved_properties: What to do with reserved properties. Can be "error" or "warning".
 
         Example:
-            Convert to DMS rules
+            Convert to Physical Data Model
             ```python
             neat.convert()
             ```
         """
         self._state._raise_exception_if_condition_not_met(
-            "Convert to physical", has_dms_rules=False, has_information_rules=True
+            "Convert to physical",
+            has_physical_data_model=False,
+            has_conceptual_data_model=True,
         )
-        converter = InformationToDMS(reserved_properties=reserved_properties, client=self._state.client)
+        converter = ConceptualToPhysical(reserved_properties=reserved_properties, client=self._state.client)
 
         issues = self._state.rule_transform(converter)
 
         if self._verbose and not issues.has_errors:
-            print("Rules converted to dms.")
+            print("Conceptual data model converted to physical data model.")
         else:
             print("Conversion failed.")
         if issues:
@@ -231,50 +233,54 @@ class NeatSession:
         ),
     ) -> IssueList:
         """Infer data model from instances."""
-        last_entity: RulesEntity | None = None
-        if self._state.rule_store.provenance:
-            last_entity = self._state.rule_store.provenance[-1].target_entity
-
-        # Note that this importer behaves as a transformer in the rule store when there is an existing rules.
-        # We are essentially transforming the last entity's information rules into a new set of information rules.
+        last_entity: DataModelEntity | None = None
+        if self._state.data_model_store.provenance:
+            last_entity = self._state.data_model_store.provenance[-1].target_entity
+
+        # Note that this importer behaves as a transformer in the data model store when there
+        # is an existing data model.
+        # We are essentially transforming the last entity's conceptual data model
+        # into a new conceptual data model.
         importer = importers.SubclassInferenceImporter(
             issue_list=IssueList(),
             graph=self._state.instances.store.graph(),
-            rules=last_entity.information if last_entity is not None else None,
-            data_model_id=dm.DataModelId.load(model_id) if last_entity is None else None,
+            data_model=last_entity.conceptual if last_entity is not None else None,
+            data_model_id=(dm.DataModelId.load(model_id) if last_entity is None else None),
         )
 
-        def action() -> tuple[ConceptualDataModel, DMSRules | None]:
-            unverified_information = importer.to_rules()
-            unverified_information = ToDMSCompliantEntities(rename_warning="raise").transform(unverified_information)
+        def action() -> tuple[ConceptualDataModel, PhysicalDataModel | None]:
+            unverified_conceptual = importer.to_data_model()
+            unverified_conceptual = ToDMSCompliantEntities(rename_warning="raise").transform(unverified_conceptual)
 
-            extra_info = VerifyInformationRules().transform(unverified_information)
+            extra_conceptual = VerifyConceptualDataModel().transform(unverified_conceptual)
             if not last_entity:
-                return extra_info, None
-            merged_info = MergeInformationRules(extra_info).transform(last_entity.information)
-            if not last_entity.dms:
-                return merged_info, None
+                return extra_conceptual, None
+            merged_conceptual = MergeConceptualDataModels(extra_conceptual).transform(last_entity.conceptual)
+            if not last_entity.physical:
+                return merged_conceptual, None
 
-            extra_dms = InformationToDMS(reserved_properties="warning", client=self._state.client).transform(extra_info)
+            extra_physical = ConceptualToPhysical(reserved_properties="warning", client=self._state.client).transform(
+                extra_conceptual
+            )
 
-            merged_dms = MergeDMSRules(extra_dms).transform(last_entity.dms)
-            return merged_info, merged_dms
+            merged_physical = MergePhysicalDataModels(extra_physical).transform(last_entity.physical)
+            return merged_conceptual, merged_physical
 
-        return self._state.rule_store.do_activity(action, importer)
+        return self._state.data_model_store.do_activity(action, importer)
 
     def _repr_html_(self) -> str:
         state = self._state
-        if state.instances.empty and state.rule_store.empty:
+        if state.instances.empty and state.data_model_store.empty:
             return "<strong>Empty session</strong>. Get started by reading something with the <em>.read</em> attribute."
 
         output = []
 
-        if state.rule_store.provenance:
-            last_entity = state.rule_store.provenance[-1].target_entity
-            if last_entity.dms:
-                html = last_entity.dms._repr_html_()
+        if state.data_model_store.provenance:
+            last_entity = state.data_model_store.provenance[-1].target_entity
+            if last_entity.physical:
+                html = last_entity.physical._repr_html_()
             else:
-                html = last_entity.information._repr_html_()
+                html = last_entity.conceptual._repr_html_()
             output.append(f"<H2>Data Model</H2><br />{html}")  # type: ignore
 
         if not state.instances.empty:

cognite/neat/session/_drop.py

@@ -78,7 +78,7 @@ class DropDataModelAPI:
         """
         if sum([view_external_id is not None, group is not None]) != 1:
             raise NeatSessionError("Only one of view_external_id or group can be specified.")
-        last_dms = self._state.rule_store.last_verified_dms_rules
+        last_dms = self._state.data_model_store.last_verified_physical_data_model
         if group is not None and last_dms.metadata.as_data_model_id() not in COGNITE_MODELS:
             raise NeatSessionError("Group can only be specified for CogniteCore models.")
         if view_external_id is not None:
@@ -98,6 +98,6 @@ class DropDataModelAPI:
                 )
         before = len(last_dms.views)
         issues = self._state.rule_transform(DropModelViews(view_external_id, group))
-        after = len(self._state.rule_store.last_verified_dms_rules.views)
+        after = len(self._state.data_model_store.last_verified_physical_data_model.views)
         print(f"Dropped {before - after} views.")
         return issues

cognite/neat/session/_experimental.py

@@ -10,7 +10,7 @@ class ExperimentalFeatureWarning(UserWarning):
 
 
 class ExperimentalFlags:
-    manual_rules_edit = ExperimentalFeatureWarning("enable_manual_edit")
+    manual_data_model_edit = ExperimentalFeatureWarning("enable_manual_edit")
     same_space_properties_only_export = ExperimentalFeatureWarning("same-space-properties-only")
     standardize_naming = ExperimentalFeatureWarning("standardize_naming")
     standardize_space_and_version = ExperimentalFeatureWarning("standardize_space_and_version")

cognite/neat/session/_inspect.py

@@ -62,23 +62,23 @@ class InspectAPI:
             neat.inspect.properties
             ```
         """
-        if self._state.rule_store.empty:
+        if self._state.data_model_store.empty:
             return pd.DataFrame()
-        last_entity = self._state.rule_store.provenance[-1].target_entity
-        if last_entity.dms:
-            df = last_entity.dms.properties.to_pandas()
+        last_entity = self._state.data_model_store.provenance[-1].target_entity
+        if last_entity.physical:
+            df = last_entity.physical.properties.to_pandas()
         else:
-            df = last_entity.information.properties.to_pandas()
+            df = last_entity.conceptual.properties.to_pandas()
         df.drop(columns=["neatId"], errors="ignore", inplace=True)
         return df
 
     def views(self) -> pd.DataFrame:
-        if self._state.rule_store.empty:
+        if self._state.data_model_store.empty:
             return pd.DataFrame()
-        last_entity = self._state.rule_store.provenance[-1].target_entity
-        if last_entity.dms is None:
+        last_entity = self._state.data_model_store.provenance[-1].target_entity
+        if last_entity.physical is None:
             return pd.DataFrame()
-        df = last_entity.dms.views.to_pandas()
+        df = last_entity.physical.views.to_pandas()
         df.drop(columns=["neatId"], errors="ignore", inplace=True)
         return df
 
@@ -95,7 +95,7 @@ class InspectIssues:
     def __call__(
         self,
         search: str | None = None,
-        include: Literal["all", "errors", "warning"] | Set[Literal["all", "errors", "warning"]] = "all",
+        include: (Literal["all", "errors", "warning"] | Set[Literal["all", "errors", "warning"]]) = "all",
         return_dataframe: Literal[True] = (False if IN_NOTEBOOK else True),  # type: ignore[assignment]
     ) -> pd.DataFrame: ...
 
@@ -103,7 +103,7 @@ class InspectIssues:
     def __call__(
         self,
         search: str | None = None,
-        include: Literal["all", "errors", "warning"] | Set[Literal["all", "errors", "warning"]] = "all",
+        include: (Literal["all", "errors", "warning"] | Set[Literal["all", "errors", "warning"]]) = "all",
         return_dataframe: Literal[False] = (False if IN_NOTEBOOK else True),  # type: ignore[assignment]
     ) -> None: ...
 
@@ -114,7 +114,7 @@ class InspectIssues:
         return_dataframe: bool = (False if IN_NOTEBOOK else True),  # type: ignore[assignment]
     ) -> pd.DataFrame | None:
         """Returns the issues of the current data model."""
-        issues = self._state.rule_store.last_issues
+        issues = self._state.data_model_store.last_issues
         if issues is None and self._state.instances.store.provenance:
             last_change = self._state.instances.store.provenance[-1]
             issues = last_change.target_entity.issues
@@ -180,7 +180,7 @@ class InspectOutcome:
     """
 
     def __init__(self, state: SessionState) -> None:
-        self.data_model = InspectUploadOutcome(lambda: state.rule_store.last_outcome)
+        self.data_model = InspectUploadOutcome(lambda: state.data_model_store.last_outcome)
         self.instances = InspectUploadOutcome(lambda: state.instances.last_outcome)
 
 

cognite/neat/session/_mapping.py

@@ -3,8 +3,8 @@ from cognite.neat.core._data_model.transformers import (
     AsParentPropertyId,
     ChangeViewPrefix,
     IncludeReferenced,
-    RuleMapper,
-    VerifiedRulesTransformer,
+    PhysicalDataModelMapper,
+    VerifiedDataModelTransformer,
 )
 from cognite.neat.core._issues import IssueList
 
@@ -42,21 +42,27 @@ class DataModelMappingAPI:
             neat.mapping.classic_to_core(company_prefix="WindFarmX", use_parent_property_name=True)
             ```
         """
-        if self._state.rule_store.empty:
-            raise NeatSessionError("No rules to map")
-        last_entity = self._state.rule_store.provenance[-1].target_entity
-        if last_entity.dms is None:
+        if self._state.data_model_store.empty:
+            raise NeatSessionError("No data model to map")
+        last_entity = self._state.data_model_store.provenance[-1].target_entity
+        if last_entity.physical is None:
             raise NeatSessionError("Data model not converted to DMS. Try running `neat.convert('dms')` first.")
-        rules = last_entity.dms
+        data_model = last_entity.physical
         if self._state.client is None:
             raise NeatSessionError("Client is required to map classic to core")
 
-        transformers: list[VerifiedRulesTransformer] = []
+        transformers: list[VerifiedDataModelTransformer] = []
         if company_prefix:
             transformers.append(ChangeViewPrefix("Classic", company_prefix))
         transformers.extend(
             [
-                RuleMapper(load_classic_to_core_mapping(company_prefix, rules.metadata.space, rules.metadata.version)),
+                PhysicalDataModelMapper(
+                    load_classic_to_core_mapping(
+                        company_prefix,
+                        data_model.metadata.space,
+                        data_model.metadata.version,
+                    )
+                ),
                 IncludeReferenced(self._state.client),
             ]
         )

cognite/neat/session/_read.py

@@ -15,7 +15,7 @@ from cognite.neat.core._data_model.models.entities._single_value import ViewEnti
 from cognite.neat.core._data_model.transformers import ClassicPrepareCore
 from cognite.neat.core._data_model.transformers._converters import (
     ToEnterpriseModel,
-    _SubsetEditableCDMRules,
+    _SubsetEditableCDMPhysicalDataModel,
 )
 from cognite.neat.core._instances import examples as instances_examples
 from cognite.neat.core._instances import extractors
@@ -113,7 +113,7 @@ class CDFReadAPI(BaseReadAPI):
 
         self._state._raise_exception_if_condition_not_met(
             "Read data model from CDF",
-            empty_rules_store_required=True,
+            empty_data_model_store_required=True,
             client_required=True,
         )
 
@@ -148,7 +148,7 @@ class CDFReadAPI(BaseReadAPI):
 
         self._state._raise_exception_if_condition_not_met(
             "Subset Core Data Model",
-            empty_rules_store_required=True,
+            empty_data_model_store_required=True,
             client_required=True,
         )
 
@@ -164,7 +164,7 @@ class CDFReadAPI(BaseReadAPI):
         if issues.has_errors:
             return issues
 
-        cdm_rules = self._state.rule_store.last_verified_rules
+        cdm_data_model = self._state.data_model_store.last_verified_data_model
 
         issues.extend(
             self._state.rule_transform(
@@ -182,7 +182,7 @@ class CDFReadAPI(BaseReadAPI):
 
         issues.extend(
             self._state.rule_transform(
-                _SubsetEditableCDMRules(
+                _SubsetEditableCDMPhysicalDataModel(
                     views={
                         ViewEntity(
                             space=cdm_v1.space,
@@ -195,8 +195,8 @@ class CDFReadAPI(BaseReadAPI):
             )
         )
 
-        if cdm_rules and not issues.has_errors:
-            self._state.last_reference = cdm_rules
+        if cdm_data_model and not issues.has_errors:
+            self._state.last_reference = cdm_data_model
 
         return issues
 
@@ -220,7 +220,7 @@ class CDFReadAPI(BaseReadAPI):
         """
         self._state._raise_exception_if_condition_not_met(
             "Read DMS Graph",
-            empty_rules_store_required=True,
+            empty_data_model_store_required=True,
             empty_instances_store_required=True,
             client_required=True,
         )
@@ -350,7 +350,7 @@ class CDFClassicAPI(BaseReadAPI):
         """
         self._state._raise_exception_if_condition_not_met(
             "Read classic graph",
-            empty_rules_store_required=True,
+            empty_data_model_store_required=True,
             empty_instances_store_required=True,
             client_required=True,
         )
@@ -399,7 +399,7 @@ class CDFClassicAPI(BaseReadAPI):
         # The above transformations creates a new type, so we need to update
         self._state.instances.neat_prefix_by_type_uri.update({namespace["ClassicSourceSystem"]: "ClassicSourceSystem_"})
         # Updating the information model.
-        prepare_issues = self._state.rule_store.transform(
+        prepare_issues = self._state.data_model_store.transform(
             ClassicPrepareCore(namespace, reference_timeseries, reference_files)
         )
 
@@ -432,7 +432,7 @@ class CDFClassicAPI(BaseReadAPI):
         namespace = CLASSIC_CDF_NAMESPACE
         self._state._raise_exception_if_condition_not_met(
             "Read time series",
-            empty_rules_store_required=True,
+            empty_data_model_store_required=True,
             empty_instances_store_required=True,
             client_required=True,
         )
@@ -491,7 +491,7 @@ class CDFClassicAPI(BaseReadAPI):
         namespace = CLASSIC_CDF_NAMESPACE
         self._state._raise_exception_if_condition_not_met(
             "Read time series",
-            empty_rules_store_required=True,
+            empty_data_model_store_required=True,
             empty_instances_store_required=True,
             client_required=True,
         )
@@ -528,15 +528,15 @@ class CDFClassicAPI(BaseReadAPI):
 
 @session_class_wrapper
 class ExcelReadAPI(BaseReadAPI):
-    """Reads a Neat Excel Rules sheet to the graph store. The rules sheet may stem from an Information architect,
-    or a DMS Architect.
+    """Reads a Neat Excel Data Model to the data model store.
+    The data model spreadsheets may contain conceptual or physical data model definitions.
 
     Args:
         io: file path to the Excel sheet
 
     Example:
         ```python
-        neat.read.excel("information_or_dms_rules_sheet.xlsx")
+        neat.read.excel("conceptual_or_physical_data_model.xlsx")
         ```
     """
 
@@ -544,27 +544,28 @@ class ExcelReadAPI(BaseReadAPI):
         super().__init__(state, verbose)
 
     def __call__(self, io: Any, enable_manual_edit: bool = False) -> IssueList:
-        """Reads a Neat Excel Rules sheet to the graph store. The rules sheet may stem from an Information architect,
-        or a DMS Architect.
+        """Reads a Neat Excel Data Model to the data model store.
+        The data model spreadsheets may contain conceptual or physical data model definitions.
 
-        Args:
-            io: file path to the Excel sheet
-            enable_manual_edit: If True, the user will be able to re-import rules which where edit outside NeatSession
+            Args:
+                io: file path to the Excel sheet
+                enable_manual_edit: If True, the user will be able to re-import data model
+                    which where edit outside NeatSession
 
-        !!! note "Manual Edit Warning"
-            This is an alpha feature and is subject to change without notice.
-            It is expected to have some limitations and may not work as expected in all cases.
+            !!! note "Manual Edit Warning"
+                This is an alpha feature and is subject to change without notice.
+                It is expected to have some limitations and may not work as expected in all cases.
         """
         reader = NeatReader.create(io)
         path = reader.materialize_path()
 
         if enable_manual_edit:
             warnings.filterwarnings("default")
-            ExperimentalFlags.manual_rules_edit.warn()
+            ExperimentalFlags.manual_data_model_edit.warn()
         else:
             self._state._raise_exception_if_condition_not_met(
-                "Read Excel Rules",
-                empty_rules_store_required=True,
+                "Read Excel Data Model",
+                empty_data_model_store_required=True,
             )
 
         return self._state.rule_import(importers.ExcelImporter(path), enable_manual_edit)
@@ -573,7 +574,8 @@ class ExcelReadAPI(BaseReadAPI):
 @session_class_wrapper
 class YamlReadAPI(BaseReadAPI):
     def __call__(self, io: Any, format: Literal["neat", "toolkit"] = "neat") -> IssueList:
-        """Reads a yaml with either neat rules, or several toolkit yaml files to import Data Model(s) into NeatSession.
+        """Reads a yaml with either neat data mode, or several toolkit yaml files to
+        import Data Model(s) into NeatSession.
 
         Args:
             io: File path to the Yaml file in the case of "neat" yaml, or path to a zip folder or directory with several
@@ -587,13 +589,13 @@ class YamlReadAPI(BaseReadAPI):
         """
         self._state._raise_exception_if_condition_not_met(
             "Read YAML data model",
-            empty_rules_store_required=True,
+            empty_data_model_store_required=True,
         )
         reader = NeatReader.create(io)
         path = reader.materialize_path()
         importer: BaseImporter
         if format == "neat":
-            importer = importers.YAMLImporter.from_file(path, source_name=f"{reader!s}")
+            importer = importers.DictImporter.from_yaml_file(path, source_name=f"{reader!s}")
         elif format == "toolkit":
             dms_importer = importers.DMSImporter.from_path(path, self._state.client)
             if dms_importer.issue_list.has_warning_type(MissingCogniteClientWarning):
@@ -695,7 +697,7 @@ class XMLReadAPI(BaseReadAPI):
 
         self._state._raise_exception_if_condition_not_met(
             "Read DEXPI file",
-            empty_rules_store_required=True,
+            empty_data_model_store_required=True,
             empty_instances_store_required=True,
         )
 
@@ -757,7 +759,7 @@ class XMLReadAPI(BaseReadAPI):
 
         self._state._raise_exception_if_condition_not_met(
             "Read AML file",
-            empty_rules_store_required=True,
+            empty_data_model_store_required=True,
             empty_instances_store_required=True,
         )
 
@@ -817,7 +819,7 @@ class RDFReadAPI(BaseReadAPI):
 
         self._state._raise_exception_if_condition_not_met(
             "Read Ontology file",
-            empty_rules_store_required=True,
+            empty_data_model_store_required=True,
         )
 
         reader = NeatReader.create(io)
@@ -840,7 +842,7 @@ class RDFReadAPI(BaseReadAPI):
 
         self._state._raise_exception_if_condition_not_met(
             "Read IMF file",
-            empty_rules_store_required=True,
+            empty_data_model_store_required=True,
         )
 
         reader = NeatReader.create(io)
@@ -850,7 +852,7 @@ class RDFReadAPI(BaseReadAPI):
     def instances(self, io: Any) -> IssueList:
         self._state._raise_exception_if_condition_not_met(
             "Read RDF Instances",
-            empty_rules_store_required=True,
+            empty_data_model_store_required=True,
         )
         reader = NeatReader.create(io)
         self._state.instances.store.write(extractors.RdfFileExtractor(reader.materialize_path()))
@@ -898,7 +900,7 @@ class Examples:
         self._state._raise_exception_if_condition_not_met(
             "Read Nordic44 graph example",
             empty_instances_store_required=True,
-            empty_rules_store_required=True,
+            empty_data_model_store_required=True,
         )
 
         self._state.instances.store.write(extractors.RdfFileExtractor(instances_examples.nordic44_knowledge_graph))
@@ -909,7 +911,7 @@ class Examples:
 
         self._state._raise_exception_if_condition_not_met(
             "Read Pump Data Model example",
-            empty_rules_store_required=True,
+            empty_data_model_store_required=True,
         )
 
         importer: importers.ExcelImporter = importers.ExcelImporter(catalog.hello_world_pump)
@@ -920,7 +922,7 @@ class Examples:
 
         self._state._raise_exception_if_condition_not_met(
             "Read Core Data Model example",
-            empty_rules_store_required=True,
+            empty_data_model_store_required=True,
             client_required=True,
         )
 

cognite/neat/session/_set.py

@@ -3,7 +3,7 @@ from cognite.client import data_modeling as dm
 
 from cognite.neat.core._client import NeatClient
 from cognite.neat.core._constants import COGNITE_MODELS
-from cognite.neat.core._data_model.models import DMSRules
+from cognite.neat.core._data_model.models import PhysicalDataModel
 from cognite.neat.core._data_model.transformers import SetIDDMSModel
 from cognite.neat.core._instances.transformers import SetType
 from cognite.neat.core._issues import IssueList
@@ -39,11 +39,11 @@ class SetAPI:
             neat.set.data_model_id(("my_data_model_space", "MyDataModel", "v1"), name="My Data Model")
             ```
         """
-        if self._state.rule_store.empty:
-            raise NeatSessionError("No rules to set the data model ID.")
-        rules = self._state.rule_store.provenance[-1].target_entity.dms
-        if isinstance(rules, DMSRules):
-            if rules.metadata.as_data_model_id() in COGNITE_MODELS:
+        if self._state.data_model_store.empty:
+            raise NeatSessionError("No data model to set the data model ID.")
+        data_model = self._state.data_model_store.provenance[-1].target_entity.physical
+        if isinstance(data_model, PhysicalDataModel):
+            if data_model.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"

cognite/neat/session/_show.py

@@ -7,7 +7,7 @@ from IPython.display import HTML, display
 from pyvis.network import Network as PyVisNetwork  # type: ignore
 
 from cognite.neat.core._constants import IN_NOTEBOOK, IN_PYODIDE
-from cognite.neat.core._data_model.analysis._base import RulesAnalysis
+from cognite.neat.core._data_model.analysis._base import DataModelAnalysis
 from cognite.neat.core._utils.io_ import to_directory_compatible
 from cognite.neat.core._utils.rdf_ import remove_namespace_from_uri, uri_display_name
 from cognite.neat.session.exceptions import NeatSessionError
@@ -95,19 +95,19 @@ class ShowDataModelAPI(ShowBaseAPI):
         self.implements = ShowDataModelImplementsAPI(self._state)
 
     def __call__(self) -> Any:
-        if self._state.rule_store.empty:
+        if self._state.data_model_store.empty:
             raise NeatSessionError("No data model available. Try using [bold].read[/bold] to read a data model.")
 
-        last_target = self._state.rule_store.provenance[-1].target_entity
-        rules = last_target.dms or last_target.information
-        analysis = RulesAnalysis(dms=last_target.dms, information=last_target.information)
+        last_target = self._state.data_model_store.provenance[-1].target_entity
+        data_model = last_target.physical or last_target.conceptual
+        analysis = DataModelAnalysis(physical=last_target.physical, conceptual=last_target.conceptual)
 
-        if last_target.dms is not None:
-            di_graph = analysis._dms_di_graph(format="data-model")
+        if last_target.physical is not None:
+            di_graph = analysis._physical_di_graph(format="data-model")
         else:
-            di_graph = analysis._info_di_graph(format="data-model")
+            di_graph = analysis._conceptual_di_graph(format="data-model")
 
-        identifier = to_directory_compatible(str(rules.metadata.identifier))
+        identifier = to_directory_compatible(str(data_model.metadata.identifier))
         name = f"{identifier}.html"
         return self._generate_visualization(di_graph, name)
 
@@ -119,18 +119,18 @@ class ShowDataModelImplementsAPI(ShowBaseAPI):
         self._state = state
 
     def __call__(self) -> Any:
-        if self._state.rule_store.empty:
+        if self._state.data_model_store.empty:
             raise NeatSessionError("No data model available. Try using [bold].read[/bold] to read a data model.")
 
-        last_target = self._state.rule_store.provenance[-1].target_entity
-        rules = last_target.dms or last_target.information
-        analysis = RulesAnalysis(dms=last_target.dms, information=last_target.information)
+        last_target = self._state.data_model_store.provenance[-1].target_entity
+        data_model = last_target.physical or last_target.conceptual
+        analysis = DataModelAnalysis(physical=last_target.physical, conceptual=last_target.conceptual)
 
-        if last_target.dms is not None:
-            di_graph = analysis._dms_di_graph(format="implements")
+        if last_target.physical is not None:
+            di_graph = analysis._physical_di_graph(format="implements")
         else:
-            di_graph = analysis._info_di_graph(format="implements")
-        identifier = to_directory_compatible(str(rules.metadata.identifier))
+            di_graph = analysis._conceptual_di_graph(format="implements")
+        identifier = to_directory_compatible(str(data_model.metadata.identifier))
         name = f"{identifier}_implements.html"
         return self._generate_visualization(di_graph, name)
 
@@ -144,18 +144,18 @@ class ShowDataModelProvenanceAPI(ShowBaseAPI):
         self._state = state
 
     def __call__(self) -> Any:
-        if not self._state.rule_store.provenance:
+        if not self._state.data_model_store.provenance:
             raise NeatSessionError("No data model available. Try using [bold].read[/bold] to load data model.")
 
         di_graph = self._generate_dm_provenance_di_graph_and_types()
-        unique_hash = self._state.rule_store.calculate_provenance_hash(shorten=True)
+        unique_hash = self._state.data_model_store.calculate_provenance_hash(shorten=True)
         return self._generate_visualization(di_graph, name=f"data_model_provenance_{unique_hash}.html")
 
     def _generate_dm_provenance_di_graph_and_types(self) -> nx.DiGraph:
         di_graph = nx.DiGraph()
         hex_colored_types = _generate_hex_color_per_type(["Agent", "Entity", "Activity", "Export", "Pruned"])
 
-        for change in self._state.rule_store.provenance:
+        for change in self._state.data_model_store.provenance:
             source = uri_display_name(change.source_entity.id_)
             target = uri_display_name(change.target_entity.id_)
             agent = uri_display_name(change.agent.id_)
@@ -187,7 +187,10 @@ class ShowDataModelProvenanceAPI(ShowBaseAPI):
             di_graph.add_edge(source, agent, label="used", color="grey")
             di_graph.add_edge(agent, target, label="generated", color="grey")
 
-        for source_id, exports in self._state.rule_store.exports_by_source_entity_id.items():
+        for (
+            source_id,
+            exports,
+        ) in self._state.data_model_store.exports_by_source_entity_id.items():
             source_shorten = uri_display_name(source_id)
             for export in exports:
                 export_id = uri_display_name(export.target_entity.id_)