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

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_data_model
+        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,7 +589,7 @@ 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()
@@ -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

@@ -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.physical
-        if isinstance(rules, PhysicalDataModel):
-            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

@@ -95,11 +95,11 @@ 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.physical or last_target.conceptual
+        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.physical is not None:
@@ -107,7 +107,7 @@ class ShowDataModelAPI(ShowBaseAPI):
         else:
             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.physical or last_target.conceptual
+        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.physical is not None:
             di_graph = analysis._physical_di_graph(format="implements")
         else:
             di_graph = analysis._conceptual_di_graph(format="implements")
-        identifier = to_directory_compatible(str(rules.metadata.identifier))
+        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_)

cognite/neat/session/_state/README.md

@@ -1,7 +1,7 @@
 # NeatState
 
 **IN DEVELOPMENT**
-The neat state controls the `NeatGraphStore` and `NeatRuleStore`. It is implementing a state machine pattern
+The neat state controls the `NeatInstanceStore` and `NeatGraphStore`. It is implementing a state machine pattern
 to ensure valid state transitions. The diagram below shows the state machine:
 
 ```mermaid

cognite/neat/session/_state.py

@@ -25,7 +25,7 @@ class SessionState:
         client: NeatClient | None = None,
     ) -> None:
         self.instances = InstancesState(store_type, storage_path=storage_path)
-        self.rule_store = NeatDataModelStore()
+        self.data_model_store = NeatDataModelStore()
         self.last_reference: PhysicalDataModel | ConceptualDataModel | None = None
         self.client = client
         self.quoted_source_identifiers = False
@@ -33,23 +33,23 @@ class SessionState:
     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
-        issues = self.rule_store.transform(*transformer)
-        last_entity = self.rule_store.provenance[-1].target_entity
+        start = self.data_model_store.provenance[-1].target_entity.display_name
+        issues = self.data_model_store.transform(*transformer)
+        last_entity = self.data_model_store.provenance[-1].target_entity
         issues.action = f"{start} → {last_entity.display_name}"
         issues.hint = "Use the .inspect.issues() for more details."
         return issues
 
     def rule_import(self, importer: BaseImporter, enable_manual_edit: bool = False) -> IssueList:
-        issues = self.rule_store.import_data_model(
+        issues = self.data_model_store.import_data_model(
             importer,
             client=self.client,
             enable_manual_edit=enable_manual_edit,
         )
-        if self.rule_store.empty:
+        if self.data_model_store.empty:
             result = "failed"
         else:
-            result = self.rule_store.provenance[-1].target_entity.display_name
+            result = self.data_model_store.provenance[-1].target_entity.display_name
         if isinstance(importer, InferenceImporter):
             issues.action = f"Inferred {result}"
         else:
@@ -60,19 +60,19 @@ class SessionState:
 
     def write_graph(self, extractor: KnowledgeGraphExtractor) -> IssueList:
         extract_issues = self.instances.store.write(extractor)
-        issues = self.rule_store.import_graph(extractor)
+        issues = self.data_model_store.import_graph(extractor)
         issues.extend(extract_issues)
         return issues
 
     def _raise_exception_if_condition_not_met(
         self,
         activity: str,
-        empty_rules_store_required: bool = False,
+        empty_data_model_store_required: bool = False,
         empty_instances_store_required: bool = False,
         instances_required: bool = False,
         client_required: bool = False,
-        has_information_rules: bool | None = None,
-        has_dms_rules: bool | None = None,
+        has_conceptual_data_model: bool | None = None,
+        has_physical_data_model: bool | None = None,
     ) -> None:
         """Set conditions for raising an error in the session that are used by various methods in the session."""
         condition = set()
@@ -81,14 +81,14 @@ 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_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_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")
+        if has_conceptual_data_model is True and self.data_model_store.try_get_last_conceptual_data_model is None:
+            condition.add(f"{activity} expects conceptual data model in NEAT session")
+            suggestion.add("Read in conceptual data model to neat session")
+        if has_physical_data_model is False and self.data_model_store.try_get_last_physical_data_model is not None:
+            condition.add(f"{activity} expects no physical data model in NEAT session")
+            suggestion.add("You already have a physical data model in the session")
             try_again = False
-        if empty_rules_store_required and not self.rule_store.empty:
+        if empty_data_model_store_required and not self.data_model_store.empty:
             condition.add(f"{activity} expects no data model in NEAT session")
             suggestion.add("Start new session")
         if empty_instances_store_required and not self.instances.empty:

cognite/neat/session/_subset.py

@@ -49,14 +49,14 @@ class SubsetAPI:
             neat.subset.data_model("CogniteAsset")
             ```
         """
-        if self._state.rule_store.empty:
-            raise NeatSessionError("No rules to set the data model ID.")
+        if self._state.data_model_store.empty:
+            raise NeatSessionError("No data model to set the data model ID.")
 
         warnings.filterwarnings("default")
         ExperimentalFlags.data_model_subsetting.warn()
 
-        dms = self._state.rule_store.provenance[-1].target_entity.physical
-        information = self._state.rule_store.provenance[-1].target_entity.conceptual
+        dms = self._state.data_model_store.provenance[-1].target_entity.physical
+        information = self._state.data_model_store.provenance[-1].target_entity.conceptual
 
         if dms:
             views = {
@@ -70,14 +70,14 @@ class SubsetAPI:
 
             issues = self._state.rule_transform(SubsetPhysicalDataModel(views=views))
             if not issues:
-                after = len(self._state.rule_store.last_verified_physical_data_model.views)
+                after = len(self._state.data_model_store.last_verified_physical_data_model.views)
 
         elif information:
             classes = {ConceptEntity(prefix=information.metadata.space, suffix=concept) for concept in concepts}
 
             issues = self._state.rule_transform(SubsetConceptualDataModel(concepts=classes))
             if not issues:
-                after = len(self._state.rule_store.last_verified_conceptual_data_model.concepts)
+                after = len(self._state.data_model_store.last_verified_conceptual_data_model.concepts)
 
         else:
             raise NeatSessionError("Something went terrible wrong. Please contact the neat team.")

cognite/neat/session/_template.py

@@ -69,7 +69,7 @@ class TemplateAPI:
                 - Charts
 
         """
-        last_rules = self._state.rule_store.last_verified_data_model
+        last_dm = self._state.data_model_store.last_verified_data_model
         issues = self._state.rule_transform(
             ToEnterpriseModel(
                 new_model_id=data_model_id,
@@ -78,8 +78,8 @@ class TemplateAPI:
                 move_connections=True,
             )
         )
-        if last_rules and not issues.has_errors:
-            self._state.last_reference = last_rules
+        if last_dm and not issues.has_errors:
+            self._state.last_reference = last_dm
         return issues
 
     def data_product_model(
@@ -105,9 +105,9 @@ 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_data_model
+        last_dm = self._state.data_model_store.last_verified_data_model
         view_ids, container_ids = PhysicalValidation(
-            self._state.rule_store.last_verified_physical_data_model
+            self._state.data_model_store.last_verified_physical_data_model
         ).imported_views_and_containers_ids()
         transformers: list[VerifiedDataModelTransformer] = []
         client = self._state.client
@@ -123,8 +123,8 @@ class TemplateAPI:
         transformers.append(ToDataProductModel(new_model_id=data_model_id, include=include))
 
         issues = self._state.rule_transform(*transformers)
-        if last_rules and not issues.has_errors:
-            self._state.last_reference = last_rules
+        if last_dm and not issues.has_errors:
+            self._state.last_reference = last_dm
         return issues
 
     def conceptual_model(
@@ -187,14 +187,16 @@ class TemplateAPI:
         with catch_issues() as issues:
             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 data model arise None there will be issues that are already caught.
                 if not isinstance(read.unverified_data_model, UnverifiedConceptualDataModel):
-                    raise NeatSessionError(f"The input {reader.name} must contain an InformationInputRules object. ")
+                    raise NeatSessionError(
+                        f"The input {reader.name} must contain an UnverifiedConceptualDataModel 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.unverified_data_model is not None:
-                    # If rules are None there will be issues that are already caught.
+                    # If data model is None there will be issues that are already caught.
                     info = modified.unverified_data_model.as_verified_data_model()
 
                     ExcelExporter(styling="maximal").export_to_file(info, output_path)
@@ -202,5 +204,5 @@ class TemplateAPI:
 
         # Adding issues to the state in the rule store
         if issues:
-            self._state.rule_store._last_issues = issues
+            self._state.data_model_store._last_issues = issues
         return issues