cognite-neat 0.121.0__py3-none-any.whl → 0.121.2__py3-none-any.whl

cognite/neat/session/_base.py

@@ -6,20 +6,22 @@ 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 PhysicalDataModel
+from cognite.neat.core._data_model.models.conceptual._verified import (
+    ConceptualDataModel,
+)
+from cognite.neat.core._data_model.transformers import (
+    ConceptualToPhysical,
+    MergeConceptualDataModels,
+    MergePhysicalDataModels,
+    ToDMSCompliantEntities,
+    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._rules import importers
-from cognite.neat.core._rules.models import DMSRules
-from cognite.neat.core._rules.models.information._rules import InformationRules
-from cognite.neat.core._rules.transformers import (
-    InformationToDMS,
-    MergeDMSRules,
-    MergeInformationRules,
-    ToDMSCompliantEntities,
-    VerifyInformationRules,
-)
-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
@@ -168,7 +170,7 @@ class NeatSession:
         self._state._raise_exception_if_condition_not_met(
             "Convert to physical", has_dms_rules=False, has_information_rules=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)
 
@@ -229,7 +231,7 @@ class NeatSession:
         ),
     ) -> IssueList:
         """Infer data model from instances."""
-        last_entity: RulesEntity | None = None
+        last_entity: DataModelEntity | None = None
         if self._state.rule_store.provenance:
             last_entity = self._state.rule_store.provenance[-1].target_entity
 
@@ -238,24 +240,26 @@ class NeatSession:
         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,
+            rules=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[InformationRules, DMSRules | None]:
-            unverified_information = importer.to_rules()
+        def action() -> tuple[ConceptualDataModel, PhysicalDataModel | None]:
+            unverified_information = importer.to_data_model()
             unverified_information = ToDMSCompliantEntities(rename_warning="raise").transform(unverified_information)
 
-            extra_info = VerifyInformationRules().transform(unverified_information)
+            extra_info = VerifyConceptualDataModel().transform(unverified_information)
             if not last_entity:
                 return extra_info, None
-            merged_info = MergeInformationRules(extra_info).transform(last_entity.information)
-            if not last_entity.dms:
+            merged_info = MergeConceptualDataModels(extra_info).transform(last_entity.conceptual)
+            if not last_entity.physical:
                 return merged_info, None
 
-            extra_dms = InformationToDMS(reserved_properties="warning", client=self._state.client).transform(extra_info)
+            extra_dms = ConceptualToPhysical(reserved_properties="warning", client=self._state.client).transform(
+                extra_info
+            )
 
-            merged_dms = MergeDMSRules(extra_dms).transform(last_entity.dms)
+            merged_dms = MergePhysicalDataModels(extra_dms).transform(last_entity.physical)
             return merged_info, merged_dms
 
         return self._state.rule_store.do_activity(action, importer)
@@ -269,10 +273,10 @@ class NeatSession:
 
         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 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

@@ -6,8 +6,8 @@ from cognite.client.utils.useful_types import SequenceNotStr
 from rdflib import URIRef
 
 from cognite.neat.core._constants import COGNITE_MODELS
+from cognite.neat.core._data_model.transformers import DropModelViews
 from cognite.neat.core._issues import IssueList
-from cognite.neat.core._rules.transformers import DropModelViews
 
 from ._state import SessionState
 from .exceptions import NeatSessionError, session_class_wrapper
@@ -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.rule_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.rule_store.last_verified_physical_data_model.views)
         print(f"Dropped {before - after} views.")
         return issues

cognite/neat/session/_fix.py

@@ -1,7 +1,7 @@
-from cognite.neat.core._issues._base import IssueList
-from cognite.neat.core._rules.transformers import (
+from cognite.neat.core._data_model.transformers import (
     ToCompliantEntities,
 )
+from cognite.neat.core._issues._base import IssueList
 
 from ._state import SessionState
 from .exceptions import session_class_wrapper

cognite/neat/session/_inspect.py

@@ -65,10 +65,10 @@ class InspectAPI:
         if self._state.rule_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()
+        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
 
@@ -76,9 +76,9 @@ class InspectAPI:
         if self._state.rule_store.empty:
             return pd.DataFrame()
         last_entity = self._state.rule_store.provenance[-1].target_entity
-        if last_entity.dms is None:
+        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
 

cognite/neat/session/_mapping.py

@@ -1,12 +1,12 @@
-from cognite.neat.core._issues import IssueList
-from cognite.neat.core._rules.models.mapping import load_classic_to_core_mapping
-from cognite.neat.core._rules.transformers import (
+from cognite.neat.core._data_model.models.mapping import load_classic_to_core_mapping
+from cognite.neat.core._data_model.transformers import (
     AsParentPropertyId,
     ChangeViewPrefix,
     IncludeReferenced,
-    RuleMapper,
-    VerifiedRulesTransformer,
+    PhysicalDataModelMapper,
+    VerifiedDataModelTransformer,
 )
+from cognite.neat.core._issues import IssueList
 
 from ._state import SessionState
 from .exceptions import NeatSessionError, session_class_wrapper
@@ -45,18 +45,20 @@ class DataModelMappingAPI:
         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 last_entity.physical is None:
             raise NeatSessionError("Data model not converted to DMS. Try running `neat.convert('dms')` first.")
-        rules = last_entity.dms
+        rules = 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, rules.metadata.space, rules.metadata.version)
+                ),
                 IncludeReferenced(self._state.client),
             ]
         )

cognite/neat/session/_prepare.py

@@ -4,17 +4,17 @@ from typing import Any
 
 from rdflib import URIRef
 
-from cognite.neat.core._graph.transformers import (
+from cognite.neat.core._data_model.transformers import PrefixEntities, StandardizeNaming
+from cognite.neat.core._data_model.transformers._converters import StandardizeSpaceAndVersion
+from cognite.neat.core._instances.transformers import (
     ConnectionToLiteral,
     ConvertLiteral,
     LiteralToEntity,
     RelationshipAsEdgeTransformer,
 )
-from cognite.neat.core._graph.transformers._rdfpath import MakeConnectionOnExactMatch
+from cognite.neat.core._instances.transformers._rdfpath import MakeConnectionOnExactMatch
 from cognite.neat.core._issues import IssueList
 from cognite.neat.core._issues.errors import NeatValueError
-from cognite.neat.core._rules.transformers import PrefixEntities, StandardizeNaming
-from cognite.neat.core._rules.transformers._converters import StandardizeSpaceAndVersion
 from cognite.neat.core._utils.text import humanize_collection
 from cognite.neat.session._experimental import ExperimentalFlags
 

cognite/neat/session/_read.py

@@ -9,15 +9,23 @@ from cognite.neat.core._constants import (
     CLASSIC_CDF_NAMESPACE,
     get_default_prefixes_and_namespaces,
 )
-from cognite.neat.core._graph import examples as instances_examples
-from cognite.neat.core._graph import extractors
-from cognite.neat.core._graph.extractors._classic_cdf._base import InstanceIdPrefix
-from cognite.neat.core._graph.transformers import (
+from cognite.neat.core._data_model import catalog, importers
+from cognite.neat.core._data_model.importers import BaseImporter
+from cognite.neat.core._data_model.models.entities._single_value import ViewEntity
+from cognite.neat.core._data_model.transformers import ClassicPrepareCore
+from cognite.neat.core._data_model.transformers._converters import (
+    ToEnterpriseModel,
+    _SubsetEditableCDMRules,
+)
+from cognite.neat.core._instances import examples as instances_examples
+from cognite.neat.core._instances import extractors
+from cognite.neat.core._instances.extractors._classic_cdf._base import InstanceIdPrefix
+from cognite.neat.core._instances.transformers import (
     ConvertLiteral,
     LiteralToEntity,
     Transformers,
 )
-from cognite.neat.core._graph.transformers._prune_graph import (
+from cognite.neat.core._instances.transformers._prune_graph import (
     AttachPropertyFromTargetToSource,
     PruneDeadEndEdges,
     PruneInstancesOfUnknownType,
@@ -26,14 +34,6 @@ from cognite.neat.core._graph.transformers._prune_graph import (
 from cognite.neat.core._issues import IssueList
 from cognite.neat.core._issues.errors import NeatValueError
 from cognite.neat.core._issues.warnings import MissingCogniteClientWarning
-from cognite.neat.core._rules import catalog, importers
-from cognite.neat.core._rules.importers import BaseImporter
-from cognite.neat.core._rules.models.entities._single_value import ViewEntity
-from cognite.neat.core._rules.transformers import ClassicPrepareCore
-from cognite.neat.core._rules.transformers._converters import (
-    ToEnterpriseModel,
-    _SubsetEditableCDMRules,
-)
 from cognite.neat.core._utils.reader import NeatReader
 from cognite.neat.session._experimental import ExperimentalFlags
 
@@ -164,7 +164,7 @@ class CDFReadAPI(BaseReadAPI):
         if issues.has_errors:
             return issues
 
-        cdm_rules = self._state.rule_store.last_verified_rules
+        cdm_rules = self._state.rule_store.last_verified_data_model
 
         issues.extend(
             self._state.rule_transform(
@@ -593,7 +593,7 @@ class YamlReadAPI(BaseReadAPI):
         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):

cognite/neat/session/_set.py

@@ -3,11 +3,11 @@ 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._graph.transformers import SetType
+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
 from cognite.neat.core._issues.errors import NeatValueError
-from cognite.neat.core._rules.models import DMSRules
-from cognite.neat.core._rules.transformers import SetIDDMSModel
 from cognite.neat.core._utils.text import humanize_collection
 
 from ._state import SessionState
@@ -41,8 +41,8 @@ class SetAPI:
         """
         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):
+        rules = self._state.rule_store.provenance[-1].target_entity.physical
+        if isinstance(rules, PhysicalDataModel):
             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"

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._rules.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
@@ -99,13 +99,13 @@ class ShowDataModelAPI(ShowBaseAPI):
             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)
+        rules = 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))
         name = f"{identifier}.html"
@@ -123,13 +123,13 @@ class ShowDataModelImplementsAPI(ShowBaseAPI):
             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)
+        rules = 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")
+            di_graph = analysis._conceptual_di_graph(format="implements")
         identifier = to_directory_compatible(str(rules.metadata.identifier))
         name = f"{identifier}_implements.html"
         return self._generate_visualization(di_graph, name)

cognite/neat/session/_state.py

@@ -4,14 +4,14 @@ from typing import Literal, cast
 from rdflib import URIRef
 
 from cognite.neat.core._client import NeatClient
-from cognite.neat.core._graph.extractors import KnowledgeGraphExtractor
-from cognite.neat.core._issues import IssueList
-from cognite.neat.core._rules.importers import BaseImporter, InferenceImporter
-from cognite.neat.core._rules.models import DMSRules, InformationRules
-from cognite.neat.core._rules.transformers import (
-    VerifiedRulesTransformer,
+from cognite.neat.core._data_model.importers import BaseImporter, InferenceImporter
+from cognite.neat.core._data_model.models import ConceptualDataModel, PhysicalDataModel
+from cognite.neat.core._data_model.transformers import (
+    VerifiedDataModelTransformer,
 )
-from cognite.neat.core._store import NeatGraphStore, NeatRulesStore
+from cognite.neat.core._instances.extractors import KnowledgeGraphExtractor
+from cognite.neat.core._issues import IssueList
+from cognite.neat.core._store import NeatDataModelStore, NeatInstanceStore
 from cognite.neat.core._utils.upload import UploadResultList
 
 from .exceptions import NeatSessionError, _session_method_wrapper
@@ -25,12 +25,12 @@ class SessionState:
         client: NeatClient | None = None,
     ) -> None:
         self.instances = InstancesState(store_type, storage_path=storage_path)
-        self.rule_store = NeatRulesStore()
-        self.last_reference: DMSRules | InformationRules | None = None
+        self.rule_store = NeatDataModelStore()
+        self.last_reference: PhysicalDataModel | ConceptualDataModel | None = None
         self.client = client
         self.quoted_source_identifiers = False
 
-    def rule_transform(self, *transformer: VerifiedRulesTransformer) -> IssueList:
+    def rule_transform(self, *transformer: VerifiedDataModelTransformer) -> IssueList:
         if not transformer:
             raise NeatSessionError("No transformers provided.")
         start = self.rule_store.provenance[-1].target_entity.display_name
@@ -41,7 +41,7 @@ class SessionState:
         return issues
 
     def rule_import(self, importer: BaseImporter, enable_manual_edit: bool = False) -> IssueList:
-        issues = self.rule_store.import_rules(
+        issues = self.rule_store.import_data_model(
             importer,
             client=self.client,
             enable_manual_edit=enable_manual_edit,
@@ -81,10 +81,10 @@ class SessionState:
         if client_required and not self.client:
             condition.add(f"{activity} expects a client in NEAT session")
             suggestion.add("Please provide a client")
-        if has_information_rules is True and self.rule_store.try_get_last_information_rules is None:
+        if has_information_rules is True and self.rule_store.try_get_last_conceptual_data_model is None:
             condition.add(f"{activity} expects information rules in NEAT session")
             suggestion.add("Read in information rules to neat session")
-        if has_dms_rules is False and self.rule_store.try_get_last_dms_rules is not None:
+        if has_dms_rules is False and self.rule_store.try_get_last_physical_data_model is not None:
             condition.add(f"{activity} expects no DMS data model in NEAT session")
             suggestion.add("You already have a DMS data model in the session")
             try_again = False
@@ -121,18 +121,18 @@ class InstancesState:
         self.neat_prefix_by_type_uri: dict[URIRef, str] = {}
 
         # Ensure that error handling is done in the constructor
-        self.store: NeatGraphStore = _session_method_wrapper(self._create_store, "NeatSession")()
+        self.store: NeatInstanceStore = _session_method_wrapper(self._create_store, "NeatSession")()
 
         if self.storage_path:
             print("Remember to close neat session .close() once you are done to avoid oxigraph lock.")
 
-    def _create_store(self) -> NeatGraphStore:
+    def _create_store(self) -> NeatInstanceStore:
         if self.store_type == "oxigraph":
             if self.storage_path:
                 self.storage_path.mkdir(parents=True, exist_ok=True)
-            return NeatGraphStore.from_oxi_local_store(storage_dir=self.storage_path)
+            return NeatInstanceStore.from_oxi_local_store(storage_dir=self.storage_path)
         else:
-            return NeatGraphStore.from_memory_store()
+            return NeatInstanceStore.from_memory_store()
 
     @property
     def empty(self) -> bool:

cognite/neat/session/_subset.py

@@ -1,11 +1,14 @@
 import warnings
 
-from cognite.neat.core._issues._base import IssueList
-from cognite.neat.core._rules.models.entities._single_value import (
-    ClassEntity,
+from cognite.neat.core._data_model.models.entities._single_value import (
+    ConceptEntity,
     ViewEntity,
 )
-from cognite.neat.core._rules.transformers import SubsetDMSRules, SubsetInformationRules
+from cognite.neat.core._data_model.transformers import (
+    SubsetConceptualDataModel,
+    SubsetPhysicalDataModel,
+)
+from cognite.neat.core._issues._base import IssueList
 from cognite.neat.session._experimental import ExperimentalFlags
 
 from ._state import SessionState
@@ -52,8 +55,8 @@ class SubsetAPI:
         warnings.filterwarnings("default")
         ExperimentalFlags.data_model_subsetting.warn()
 
-        dms = self._state.rule_store.provenance[-1].target_entity.dms
-        information = self._state.rule_store.provenance[-1].target_entity.information
+        dms = self._state.rule_store.provenance[-1].target_entity.physical
+        information = self._state.rule_store.provenance[-1].target_entity.conceptual
 
         if dms:
             views = {
@@ -65,16 +68,16 @@ class SubsetAPI:
                 for concept in concepts
             }
 
-            issues = self._state.rule_transform(SubsetDMSRules(views=views))
+            issues = self._state.rule_transform(SubsetPhysicalDataModel(views=views))
             if not issues:
-                after = len(self._state.rule_store.last_verified_dms_rules.views)
+                after = len(self._state.rule_store.last_verified_physical_data_model.views)
 
         elif information:
-            classes = {ClassEntity(prefix=information.metadata.space, suffix=concept) for concept in concepts}
+            classes = {ConceptEntity(prefix=information.metadata.space, suffix=concept) for concept in concepts}
 
-            issues = self._state.rule_transform(SubsetInformationRules(classes=classes))
+            issues = self._state.rule_transform(SubsetConceptualDataModel(concepts=classes))
             if not issues:
-                after = len(self._state.rule_store.last_verified_information_rules.classes)
+                after = len(self._state.rule_store.last_verified_conceptual_data_model.concepts)
 
         else:
             raise NeatSessionError("Something went terrible wrong. Please contact the neat team.")

cognite/neat/session/_template.py

@@ -4,20 +4,20 @@ from typing import Any, Literal
 from cognite.client.data_classes.data_modeling import DataModelIdentifier
 
 from cognite.neat.core._constants import BASE_MODEL
-from cognite.neat.core._issues import IssueList, catch_issues
-from cognite.neat.core._rules._shared import ReadRules
-from cognite.neat.core._rules.exporters import ExcelExporter
-from cognite.neat.core._rules.importers import ExcelImporter
-from cognite.neat.core._rules.models import InformationInputRules
-from cognite.neat.core._rules.models._base_rules import RoleTypes
-from cognite.neat.core._rules.models.dms import DMSValidation
-from cognite.neat.core._rules.transformers import (
+from cognite.neat.core._data_model._shared import ImportedDataModel
+from cognite.neat.core._data_model.exporters import ExcelExporter
+from cognite.neat.core._data_model.importers import ExcelImporter
+from cognite.neat.core._data_model.models import UnverifiedConceptualDataModel
+from cognite.neat.core._data_model.models._base_verified import RoleTypes
+from cognite.neat.core._data_model.models.physical import PhysicalValidation
+from cognite.neat.core._data_model.transformers import (
     AddCogniteProperties,
     IncludeReferenced,
     ToDataProductModel,
     ToEnterpriseModel,
-    VerifiedRulesTransformer,
+    VerifiedDataModelTransformer,
 )
+from cognite.neat.core._issues import IssueList, catch_issues
 from cognite.neat.core._utils.reader import NeatReader, PathReader
 from cognite.neat.session._experimental import ExperimentalFlags
 
@@ -69,7 +69,7 @@ class TemplateAPI:
                 - Charts
 
         """
-        last_rules = self._state.rule_store.last_verified_rules
+        last_rules = self._state.rule_store.last_verified_data_model
         issues = self._state.rule_transform(
             ToEnterpriseModel(
                 new_model_id=data_model_id,
@@ -105,11 +105,11 @@ class TemplateAPI:
                 If you set same-space, only the properties of the views in the same space as the data model
                 will be included.
         """
-        last_rules = self._state.rule_store.last_verified_rules
-        view_ids, container_ids = DMSValidation(
-            self._state.rule_store.last_verified_dms_rules
+        last_rules = self._state.rule_store.last_verified_data_model
+        view_ids, container_ids = PhysicalValidation(
+            self._state.rule_store.last_verified_physical_data_model
         ).imported_views_and_containers_ids()
-        transformers: list[VerifiedRulesTransformer] = []
+        transformers: list[VerifiedDataModelTransformer] = []
         client = self._state.client
         if (view_ids or container_ids) and client is None:
             raise NeatSessionError(
@@ -185,17 +185,17 @@ class TemplateAPI:
             output_path = Path(output)
 
         with catch_issues() as issues:
-            read: ReadRules[InformationInputRules] = ExcelImporter(path).to_rules()
-            if read.rules is not None:
+            read: ImportedDataModel[UnverifiedConceptualDataModel] = ExcelImporter(path).to_data_model()
+            if read.unverified_data_model is not None:
                 # If rules are None there will be issues that are already caught.
-                if not isinstance(read.rules, InformationInputRules):
+                if not isinstance(read.unverified_data_model, UnverifiedConceptualDataModel):
                     raise NeatSessionError(f"The input {reader.name} must contain an InformationInputRules object. ")
                 if self._state.client is None:
                     raise NeatSessionError("Client must be set in the session to run the extension.")
                 modified = AddCogniteProperties(self._state.client, dummy_property).transform(read)
-                if modified.rules is not None:
+                if modified.unverified_data_model is not None:
                     # If rules are None there will be issues that are already caught.
-                    info = modified.rules.as_verified_rules()
+                    info = modified.unverified_data_model.as_verified_data_model()
 
                     ExcelExporter(styling="maximal").export_to_file(info, output_path)
         issues.action = "Created extension template"