cognite-neat 0.121.1__py3-none-any.whl → 0.121.2__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
@@ -170,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)
 
@@ -231,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
 
@@ -240,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[ConceptualDataModel, 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)
@@ -271,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

@@ -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/_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

@@ -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
 
@@ -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/_read.py

@@ -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,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
@@ -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._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
@@ -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

@@ -5,13 +5,13 @@ from rdflib import URIRef
 
 from cognite.neat.core._client import NeatClient
 from cognite.neat.core._data_model.importers import BaseImporter, InferenceImporter
-from cognite.neat.core._data_model.models import ConceptualDataModel, DMSRules
+from cognite.neat.core._data_model.models import ConceptualDataModel, PhysicalDataModel
 from cognite.neat.core._data_model.transformers import (
-    VerifiedRulesTransformer,
+    VerifiedDataModelTransformer,
 )
 from cognite.neat.core._instances.extractors import KnowledgeGraphExtractor
 from cognite.neat.core._issues import IssueList
-from cognite.neat.core._store import NeatGraphStore, NeatRulesStore
+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 | ConceptualDataModel | 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,10 +1,13 @@
 import warnings
 
 from cognite.neat.core._data_model.models.entities._single_value import (
-    ClassEntity,
+    ConceptEntity,
     ViewEntity,
 )
-from cognite.neat.core._data_model.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
 
@@ -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,18 +4,18 @@ 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._data_model._shared import ReadRules
+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.dms import DMSValidation
+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
@@ -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[UnverifiedConceptualDataModel] = 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, UnverifiedConceptualDataModel):
+                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"

cognite/neat/session/_to.py

@@ -10,10 +10,10 @@ from cognite.neat.core._client._api_client import NeatClient
 from cognite.neat.core._constants import COGNITE_MODELS
 from cognite.neat.core._data_model import exporters
 from cognite.neat.core._data_model._constants import PATTERNS
-from cognite.neat.core._data_model._shared import VerifiedRules
+from cognite.neat.core._data_model._shared import VerifiedDataModel
 from cognite.neat.core._data_model.importers import DMSImporter
-from cognite.neat.core._data_model.models import ConceptualDataModel, DMSRules
-from cognite.neat.core._data_model.models.dms import DMSMetadata
+from cognite.neat.core._data_model.models import ConceptualDataModel, PhysicalDataModel
+from cognite.neat.core._data_model.models.physical import PhysicalMetadata
 from cognite.neat.core._instances import loaders
 from cognite.neat.core._issues import IssueList, NeatIssue, catch_issues
 from cognite.neat.core._utils.upload import UploadResultList
@@ -113,12 +113,12 @@ class ToAPI:
             dms_rules_file_name = "dms_rules.xlsx"
             neat.to.excel(dms_rules_file_name, include_reference=("cdf_cdm", "CogniteCore", "v1"))
         """
-        reference_rules_with_prefix: tuple[VerifiedRules, str] | None = None
+        reference_data_model_with_prefix: tuple[VerifiedDataModel, str] | None = None
         include_properties = include_properties.strip().lower()
 
         if include_reference is not False:
             if include_reference is True and self._state.last_reference is not None:
-                ref_rules: ConceptualDataModel | DMSRules | None = self._state.last_reference
+                ref_rules: ConceptualDataModel | PhysicalDataModel | None = self._state.last_reference
             elif include_reference is True:
                 ref_rules = None
             else:
@@ -126,20 +126,20 @@ class ToAPI:
                     raise NeatSessionError("No client provided!")
                 ref_rules = None
                 with catch_issues() as issues:
-                    ref_read = DMSImporter.from_data_model_id(self._state.client, include_reference).to_rules()
-                    if ref_read.rules is not None:
-                        ref_rules = ref_read.rules.as_verified_rules()
+                    ref_read = DMSImporter.from_data_model_id(self._state.client, include_reference).to_data_model()
+                    if ref_read.unverified_data_model is not None:
+                        ref_rules = ref_read.unverified_data_model.as_verified_data_model()
                 if ref_rules is None or issues.has_errors:
                     issues.action = f"Read {include_reference}"
                     return issues
             if ref_rules is not None:
                 prefix = "Ref"
                 if (
-                    isinstance(ref_rules.metadata, DMSMetadata)
+                    isinstance(ref_rules.metadata, PhysicalMetadata)
                     and ref_rules.metadata.as_data_model_id() in COGNITE_MODELS
                 ):
                     prefix = "CDM"
-                reference_rules_with_prefix = ref_rules, prefix
+                reference_data_model_with_prefix = ref_rules, prefix
 
         if include_properties == "same-space":
             warnings.filterwarnings("default")
@@ -147,7 +147,7 @@ class ToAPI:
 
         exporter = exporters.ExcelExporter(
             styling="maximal",
-            reference_rules_with_prefix=reference_rules_with_prefix,
+            reference_data_model_with_prefix=reference_data_model_with_prefix,
             add_empty_rows=add_empty_rows,
             include_properties=include_properties,  # type: ignore
         )
@@ -310,7 +310,7 @@ class CDFToAPI:
         )
 
         client = cast(NeatClient, self._state.client)
-        dms_rules = self._state.rule_store.last_verified_dms_rules
+        dms_rules = self._state.rule_store.last_verified_physical_data_model
         instance_space = instance_space or f"{dms_rules.metadata.space}_instances"
 
         if instance_space and instance_space == dms_rules.metadata.space:
@@ -322,8 +322,8 @@ class CDFToAPI:
             client.data_modeling.spaces.apply(dm.SpaceApply(space=instance_space))
 
         loader = loaders.DMSLoader(
-            self._state.rule_store.last_verified_dms_rules,
-            self._state.rule_store.last_verified_information_rules,
+            self._state.rule_store.last_verified_physical_data_model,
+            self._state.rule_store.last_verified_conceptual_data_model,
             self._state.instances.store,
             instance_space=instance_space,
             client=client,
@@ -418,7 +418,7 @@ class ToPythonAPI:
             instances = neat.to._python.instances(space_from_property="dataSetId")
             ```
         """
-        dms_rules = self._state.rule_store.last_verified_dms_rules
+        dms_rules = self._state.rule_store.last_verified_physical_data_model
         instance_space = instance_space or f"{dms_rules.metadata.space}_instances"
 
         if instance_space and instance_space == dms_rules.metadata.space:
@@ -427,8 +427,8 @@ class ToPythonAPI:
             raise NeatSessionError(f"Please provide a valid space name. {PATTERNS.space_compliance.pattern}")
 
         loader = loaders.DMSLoader(
-            self._state.rule_store.last_verified_dms_rules,
-            self._state.rule_store.last_verified_information_rules,
+            self._state.rule_store.last_verified_physical_data_model,
+            self._state.rule_store.last_verified_conceptual_data_model,
             self._state.instances.store,
             instance_space=instance_space,
             space_property=space_from_property,

{cognite_neat-0.121.1.dist-info → cognite_neat-0.121.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 0.121.1
+Version: 0.121.2
 Summary: Knowledge graph transformation
 Project-URL: Documentation, https://cognite-neat.readthedocs-hosted.com/
 Project-URL: Homepage, https://cognite-neat.readthedocs-hosted.com/