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

cognite/neat/core/_data_model/models/physical/_validation.py

@@ -65,7 +65,7 @@ class PhysicalValidation:
         client: NeatClient | None = None,
         read_info_by_spreadsheet: dict[str, SpreadsheetRead] | None = None,
     ) -> None:
-        self._rules = data_model
+        self._data_model = data_model
         self._client = client
         self._metadata = data_model.metadata
         self._properties = data_model.properties
@@ -109,7 +109,7 @@ class PhysicalValidation:
         )
         if (imported_views or imported_containers) and self._client is None:
             raise CDFMissingClientError(
-                f"{self._rules.metadata.as_data_model_id()} has imported views and/or container: "
+                f"{self._data_model.metadata.as_data_model_id()} has imported views and/or container: "
                 f"{imported_views}, {imported_containers}."
             )
         referenced_views = ViewList([])
@@ -131,10 +131,10 @@ class PhysicalValidation:
                 raise CDFMissingResourcesError(containers=tuple(missing_containers), views=tuple(missing_views))
 
         # Setup data structures for validation
-        dms_schema = self._rules.as_schema()
+        dms_schema = self._data_model.as_schema()
         ref_view_by_id = {view.as_id(): view for view in referenced_views}
         ref_container_by_id = {container.as_id(): container for container in referenced_containers}
-        # All containers and views are the Containers/Views in the DMSRules + the referenced ones
+        # All containers and views are the Containers/Views in the Physical DM + the referenced ones
         all_containers_by_id: dict[dm.ContainerId, dm.ContainerApply | dm.Container] = {
             **dict(dms_schema.containers.items()),
             **ref_container_by_id,
@@ -175,7 +175,7 @@ class PhysicalValidation:
     def _same_space_views_and_data_model(self) -> IssueList:
         issue_list = IssueList()
 
-        schema = self._rules.as_schema(remove_cdf_spaces=True)
+        schema = self._data_model.as_schema(remove_cdf_spaces=True)
 
         if schema.data_model and schema.views:
             data_model_space = schema.data_model.space

cognite/neat/core/_data_model/transformers/__init__.py

@@ -6,7 +6,7 @@ from ._converters import (
     ClassicPrepareCore,
     ConceptualToPhysical,
     ConversionTransformer,
-    ConvertToRules,
+    ConvertToDataModel,
     DropModelViews,
     IncludeReferenced,
     MergeConceptualDataModels,
@@ -40,7 +40,7 @@ __all__ = [
     "ClassicPrepareCore",
     "ConceptualToPhysical",
     "ConversionTransformer",
-    "ConvertToRules",
+    "ConvertToDataModel",
     "DataModelTransformer",
     "DropModelViews",
     "IncludeReferenced",

cognite/neat/core/_data_model/transformers/_base.py

@@ -67,7 +67,7 @@ class DataModelTransformer(ABC, Generic[T_DataModelIn, T_DataModelOut]):
             return get_args(annotation)
 
         if get_origin(annotation) is ImportedDataModel and isinstance(get_args(annotation)[0], TypeVar):
-            # Hardcoded for now, as we only have two types of ReadRules
+            # Hardcoded for now, as we only have two types of imported data models
             return (
                 ImportedDataModel[UnverifiedPhysicalDataModel],
                 ImportedDataModel[UnverifiedConceptualDataModel],

cognite/neat/core/_data_model/transformers/_converters.py

@@ -110,8 +110,8 @@ from ._base import (
 )
 from ._verification import VerifyPhysicalDataModel
 
-T_InputInRules = TypeVar("T_InputInRules", bound=ImportedUnverifiedDataModel)
-T_InputOutRules = TypeVar("T_InputOutRules", bound=ImportedUnverifiedDataModel)
+T_UnverifiedInDataModel = TypeVar("T_UnverifiedInDataModel", bound=ImportedUnverifiedDataModel)
+T_UnverifiedOutDataModel = TypeVar("T_UnverifiedOutDataModel", bound=ImportedUnverifiedDataModel)
 
 
 class ConversionTransformer(VerifiedDataModelTransformer[T_VerifiedIn, T_VerifiedOut], ABC):
@@ -225,7 +225,7 @@ class ToDMSCompliantEntities(
 
 
 class StandardizeSpaceAndVersion(VerifiedDataModelTransformer[PhysicalDataModel, PhysicalDataModel]):  # type: ignore[misc]
-    """This transformer standardizes the space and version of the DMSRules.
+    """This transformer standardizes the space and version of the physical data model.
 
     typically used to ensure all the views are moved to the same version as the data model.
 
@@ -381,7 +381,7 @@ class PrefixEntities(ConversionTransformer):  # type: ignore[type-var]
     def transform(self, data_model: ConceptualDataModel | PhysicalDataModel) -> ConceptualDataModel | PhysicalDataModel:
         copy: ConceptualDataModel | PhysicalDataModel = data_model.model_copy(deep=True)
 
-        # Case: Prefix Information Rules
+        # Case: Prefix Conceptual Data Model
         if isinstance(copy, ConceptualDataModel):
             # prefix classes
             for cls in copy.concepts:
@@ -408,7 +408,7 @@ class PrefixEntities(ConversionTransformer):  # type: ignore[type-var]
                             prop.value_type.types[i] = self._with_prefix(cast(ConceptEntity, value_type))
             return copy
 
-        # Case: Prefix DMS Rules
+        # Case: Prefix Physical Data Model
         elif isinstance(copy, PhysicalDataModel):
             for view in copy.views:
                 if view.view.space == copy.metadata.space:
@@ -600,10 +600,10 @@ class PhysicalToConceptual(ConversionTransformer[PhysicalDataModel, ConceptualDa
         self.instance_namespace = instance_namespace
 
     def transform(self, data_model: PhysicalDataModel) -> ConceptualDataModel:
-        return _DMSRulesConverter(data_model, self.instance_namespace).as_conceptual_data_model()
+        return _PhysicalDataModelConverter(data_model, self.instance_namespace).as_conceptual_data_model()
 
 
-class ConvertToRules(ConversionTransformer[VerifiedDataModel, VerifiedDataModel]):
+class ConvertToDataModel(ConversionTransformer[VerifiedDataModel, VerifiedDataModel]):
     """Converts any data_model to any data_model."""
 
     def __init__(self, out_cls: type[VerifiedDataModel]):
@@ -2004,7 +2004,7 @@ class _ConceptualDataModelConverter:
         return None
 
 
-class _DMSRulesConverter:
+class _PhysicalDataModelConverter:
     def __init__(self, data_model: PhysicalDataModel, instance_namespace: Namespace | None = None) -> None:
         self.physical_data_model = data_model
         self.instance_namespace = instance_namespace
@@ -2106,7 +2106,7 @@ class _DMSRulesConverter:
         )
 
 
-class _SubsetEditableCDMRules(VerifiedDataModelTransformer[PhysicalDataModel, PhysicalDataModel]):
+class _SubsetEditableCDMPhysicalDataModel(VerifiedDataModelTransformer[PhysicalDataModel, PhysicalDataModel]):
     """Subsets editable CDM data model to only include desired set of CDM concepts.
 
     !!! note "Platypus UI limitations"

cognite/neat/core/_data_model/transformers/_verification.py

@@ -35,7 +35,7 @@ class VerificationTransformer(DataModelTransformer[T_ImportedUnverifiedDataModel
     def transform(self, data_model: T_ImportedUnverifiedDataModel) -> T_VerifiedDataModel:
         in_ = data_model.unverified_data_model
         if in_ is None:
-            raise NeatValueError("Cannot verify rules. The reading of the rules failed.")
+            raise NeatValueError("Cannot verify data model. The reading of the data model failed.")
         verified_data_model: T_VerifiedDataModel | None = None
         # We need to catch issues as we use the error args to provide extra context for the errors/warnings
         # For example, which row in the spreadsheet the error occurred.

cognite/neat/core/_instances/extractors/_base.py

@@ -39,7 +39,7 @@ class KnowledgeGraphExtractor(BaseExtractor):
 
     @abstractmethod
     def get_conceptual_data_model(self) -> ConceptualDataModel:
-        """Returns the information rules that the extractor uses."""
+        """Returns the conceptual data model that the extractor uses."""
         raise NotImplementedError()
 
     @property

cognite/neat/core/_instances/extractors/_classic_cdf/_classic.py

@@ -217,7 +217,7 @@ class ClassicGraphExtractor(KnowledgeGraphExtractor):
             ExcelImporter(classic_model).to_data_model(),
         )
         if unverified.unverified_data_model is None:
-            raise NeatValueError(f"Could not read the classic model rules from {classic_model}.")
+            raise NeatValueError(f"Could not read the classic data model from {classic_model}.")
 
         verified = unverified.unverified_data_model.as_verified_data_model()
         prefixes = get_default_prefixes_and_namespaces()

cognite/neat/core/_instances/extractors/_mock_graph_generator.py

@@ -29,8 +29,8 @@ class MockGraphGenerator(BaseExtractor):
     Class used to generate mock graph data for purposes of testing of NEAT.
 
     Args:
-        rules: Transformation rules defining the classes with their properties.
-        class_count: Target class count for each class in the ontology
+        data_model: Data model defining the concepts with their properties.
+        concept_count: Target concept count for each concept/class in the data model
         stop_on_exception: To stop if exception is encountered or not, default is False
         allow_isolated_classes: To allow generation of instances for classes that are not
                                  connected to any other class, default is True
@@ -47,37 +47,38 @@ class MockGraphGenerator(BaseExtractor):
             # fixes potential issues with circular dependencies
             from cognite.neat.core._data_model.transformers import PhysicalToConceptual
 
-            self.rules = PhysicalToConceptual().transform(data_model)
+            self.data_model = PhysicalToConceptual().transform(data_model)
         elif isinstance(data_model, ConceptualDataModel):
-            self.rules = data_model
+            self.data_model = data_model
         else:
-            raise ValueError("Rules must be of type InformationRules or DMSRules!")
+            raise ValueError("Data model must be of type Conceptual or Physical!")
 
         if not concept_count:
             self.concept_count = {
-                concept: 1 for concept in DataModelAnalysis(self.rules).defined_concepts(include_ancestors=True)
+                concept: 1 for concept in DataModelAnalysis(self.data_model).defined_concepts(include_ancestors=True)
             }
         elif all(isinstance(key, str) for key in concept_count.keys()):
             self.concept_count = {
-                ConceptEntity.load(f"{self.rules.metadata.prefix}:{key}"): value for key, value in concept_count.items()
+                ConceptEntity.load(f"{self.data_model.metadata.prefix}:{key}"): value
+                for key, value in concept_count.items()
             }
         elif all(isinstance(key, ConceptEntity) for key in concept_count.keys()):
             self.concept_count = cast(dict[ConceptEntity, int], concept_count)
         else:
-            raise ValueError("Class count keys must be of type str! or ClassEntity! or empty dict!")
+            raise ValueError("Class count keys must be of type str! or ConceptEntity! or empty dict!")
 
         self.stop_on_exception = stop_on_exception
         self.allow_isolated_classes = allow_isolated_classes
 
     def extract(self) -> list[Triple]:
-        """Generate mock triples based on data model defined transformation rules and desired number
-        of class instances
+        """Generate mock triples based on data model and desired number
+        of concept instances
 
         Returns:
             List of RDF triples, represented as tuples `(subject, predicate, object)`, that define data model instances
         """
         return generate_triples(
-            self.rules,
+            self.data_model,
             self.concept_count,
             stop_on_exception=self.stop_on_exception,
             allow_isolated_concepts=self.allow_isolated_classes,
@@ -94,8 +95,8 @@ def generate_triples(
     of class instances
 
     Args:
-        rules : Rules defining the data model
-        concept_count: Target class count for each class in the ontology
+        data_model : Data model
+        concept_count: Target concept count for each class in the data model
         stop_on_exception: To stop if exception is encountered or not, default is False
         allow_isolated_concepts: To allow generation of instances for classes that are not
                                  connected to any other class, default is True

cognite/neat/core/_instances/loaders/_base.py

@@ -29,8 +29,8 @@ class BaseLoader(ABC, Generic[T_Output]):
     _new_line = "\n"
     _encoding = "utf-8"
 
-    def __init__(self, graph_store: NeatInstanceStore):
-        self.graph_store = graph_store
+    def __init__(self, instance_store: NeatInstanceStore):
+        self.instance_store = instance_store
 
     @abstractmethod
     def write_to_file(self, filepath: Path) -> None:

cognite/neat/core/_instances/loaders/_rdf2dms.py

@@ -22,6 +22,7 @@ from rdflib import RDF, URIRef
 from cognite.neat.core._client import NeatClient
 from cognite.neat.core._client._api_client import SchemaAPI
 from cognite.neat.core._constants import (
+    COGNITE_SPACES,
     DMS_DIRECT_RELATION_LIST_DEFAULT_LIMIT,
     is_readonly_property,
 )
@@ -96,13 +97,13 @@ class _Projection:
 
 
 class DMSLoader(CDFLoader[dm.InstanceApply]):
-    """Loads Instances to Cognite Data Fusion Data Model Service from NeatGraph.
+    """Loads Instances to Cognite Data Fusion Data Model Service from NeatInstanceStore.
 
     Args:
-        dms_rules (DMSRules): The DMS rules used by the data model.
-        info_rules (InformationRules): The information rules used by the data model, used to
-            look+up the instances in the store.
-        graph_store (NeatGraphStore): The graph store to load the data from.
+        physical_data_model (PhysicalDataModel): Physical data model.
+        conceptual_data_model (ConceptualDataModel): Conceptual data model,
+            used to look+up the instances in the store.
+        instance_store (NeatInstanceStore): The instance store to load the instances from.
         instance_space (str): The instance space to load the data into.
         create_issues (Sequence[NeatIssue] | None): A list of issues that occurred during reading. Defaults to None.
         client (NeatClient | None): This is used to lookup containers such that the loader
@@ -115,9 +116,9 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
 
     def __init__(
         self,
-        dms_rules: PhysicalDataModel,
-        info_rules: ConceptualDataModel,
-        graph_store: NeatInstanceStore,
+        physical_data_model: PhysicalDataModel,
+        conceptual_data_model: ConceptualDataModel,
+        instance_store: NeatInstanceStore,
         instance_space: str,
         space_property: str | None = None,
         use_source_space: bool = False,
@@ -127,9 +128,9 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         neat_prefix_by_predicate_uri: dict[URIRef, str] | None = None,
         neat_prefix_by_type_uri: dict[URIRef, str] | None = None,
     ):
-        super().__init__(graph_store)
-        self.dms_rules = dms_rules
-        self.info_rules = info_rules
+        super().__init__(instance_store)
+        self.physical_data_model = physical_data_model
+        self.conceptual_data_model = conceptual_data_model
         self.neat_prefix_by_predicate_uri = neat_prefix_by_predicate_uri or {}
         self.neat_prefix_by_type_uri = neat_prefix_by_type_uri or {}
         self._instance_space = instance_space
@@ -192,7 +193,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             projection, issues = self._create_projection(view)
             yield from issues
             query = it.query
-            reader = self.graph_store.read(
+            reader = self.instance_store.read(
                 query.rdf_type,
                 property_renaming_config=query.property_renaming_config,
                 remove_uri_namespace=False,
@@ -209,7 +210,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             yield _END_OF_CLASS
 
     def _create_view_iterations(self) -> tuple[list[_ViewIterator], IssueList]:
-        view_query_by_id = DataModelAnalysis(self.info_rules, self.dms_rules).view_query_by_id
+        view_query_by_id = DataModelAnalysis(self.conceptual_data_model, self.physical_data_model).view_query_by_id
         iterations_by_view_id = self._select_views_with_instances(view_query_by_id)
         if self._client:
             issues = IssueList()
@@ -224,7 +225,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         else:
             views = dm.ViewList([])
             with catch_issues() as issues:
-                read_model = self.dms_rules.as_schema().as_read_model()
+                read_model = self.physical_data_model.as_schema().as_read_model()
                 views.extend(read_model.views)
             if issues.has_errors:
                 return [], issues
@@ -274,7 +275,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         """Selects the views with data."""
         view_iterations: dict[dm.ViewId, _ViewIterator] = {}
         for view_id, query in view_query_by_id.items():
-            count = self.graph_store.queries.select.count_of_type(query.rdf_type)
+            count = self.instance_store.queries.select.count_of_type(query.rdf_type)
             if count > 0:
                 view_iterations[view_id] = _ViewIterator(view_id, count, query)
         return view_iterations
@@ -284,7 +285,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         if self._space_property is None:
             return issues
         total = sum(it.instance_count for it in view_iterations)
-        properties_by_uriref = self.graph_store.queries.select.properties()
+        properties_by_uriref = self.instance_store.queries.select.properties()
         space_property_uri = next((k for k, v in properties_by_uriref.items() if v == self._space_property), None)
         if space_property_uri is None:
             error: ResourceNotFoundError[str, str] = ResourceNotFoundError(
@@ -297,7 +298,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             issues.append(error)
             return issues
 
-        instance_iterable = self.graph_store.queries.select.list_instances_ids_by_space(space_property_uri)
+        instance_iterable = self.instance_store.queries.select.list_instances_ids_by_space(space_property_uri)
         instance_iterable = iterate_progress_bar_if_above_config_threshold(
             instance_iterable, total, f"Looking up spaces for {total} instances..."
         )
@@ -323,8 +324,8 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         if not self.neat_prefix_by_type_uri:
             return
 
-        count = sum(count for _, count in self.graph_store.queries.select.summarize_instances())
-        instance_iterable = self.graph_store.queries.select.list_instances_ids()
+        count = sum(count for _, count in self.instance_store.queries.select.summarize_instances())
+        instance_iterable = self.instance_store.queries.select.list_instances_ids()
         instance_iterable = iterate_progress_bar_if_above_config_threshold(
             instance_iterable, count, f"Looking up identifiers for {count} instances..."
         )
@@ -585,7 +586,12 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             yield dm.NodeApply(
                 space=space,
                 external_id=external_id,
-                type=(projection.view_id.space, projection.view_id.external_id),
+                # Currently there are no node types for schemas in cognite schema spaces
+                type=(
+                    (projection.view_id.space, projection.view_id.external_id)
+                    if projection.view_id.space not in COGNITE_SPACES
+                    else None
+                ),
                 sources=sources,
             )
         yield from self._create_edges_without_properties(space, external_id, properties, projection, stop_on_exception)

cognite/neat/core/_instances/transformers/_rdfpath.py

@@ -10,7 +10,7 @@ from ._base import BaseTransformerStandardised, RowTransformationOutput
 
 
 class MakeConnectionOnExactMatch(BaseTransformerStandardised):
-    description: str = "Adds property that contains id of reference to all references of given class in Rules"
+    description: str = "Adds property that contains id of reference to all references of given class in model"
     _use_only_once: bool = False
     _need_changes = frozenset({})
 

cognite/neat/core/_issues/_factory.py

@@ -37,7 +37,7 @@ def _from_pydantic_error(error: ErrorDetails, read_info_by_sheet: dict[str, Spre
     if location:
         return SpreadsheetError.create(location, neat_error, read_info_by_sheet.get(cast(str, location[0])))
 
-    # errors that occur while for example parsing spreadsheet in input rules
+    # errors that occur while for example parsing spreadsheet in imported data model
     # will not have location information so we return neat_error as is
     # this is workaround until more elegant solution is found
     return neat_error

cognite/neat/core/_issues/errors/_resources.py

@@ -72,7 +72,7 @@ class ResourceNotDefinedError(ResourceError[T_Identifier]):
 class ResourceConversionError(ResourceError, ValueError):
     """Failed to convert the {resource_type} {identifier} to {target_format}: {reason}"""
 
-    fix = "Check the error message and correct the rules."
+    fix = "Check the error message and correct the data model."
     target_format: str
     reason: str
 

cognite/neat/core/_issues/warnings/_properties.py

@@ -48,7 +48,7 @@ class PropertyDefinitionDuplicatedWarning(PropertyWarning[T_Identifier]):
 @dataclass(unsafe_hash=True)
 class PropertyValueTypeUndefinedWarning(PropertyWarning[T_Identifier]):
     """The {resource_type} with identifier {identifier} has a property {property_name}
-    which has undefined value type. This may result in unexpected behavior when exporting rules.
+    which has undefined value type. This may result in unexpected behavior when exporting data model.
     {default_action}"""
 
     extra = "Recommended action: {recommended_action}"

cognite/neat/session/_base.py

@@ -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 = 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:
@@ -232,47 +234,49 @@ class NeatSession:
     ) -> IssueList:
         """Infer data model from instances."""
         last_entity: DataModelEntity | None = None
-        if self._state.rule_store.provenance:
-            last_entity = self._state.rule_store.provenance[-1].target_entity
+        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 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.
+        # 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.conceptual if last_entity is not 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, PhysicalDataModel | None]:
-            unverified_information = importer.to_data_model()
-            unverified_information = ToDMSCompliantEntities(rename_warning="raise").transform(unverified_information)
+            unverified_conceptual = importer.to_data_model()
+            unverified_conceptual = ToDMSCompliantEntities(rename_warning="raise").transform(unverified_conceptual)
 
-            extra_info = VerifyConceptualDataModel().transform(unverified_information)
+            extra_conceptual = VerifyConceptualDataModel().transform(unverified_conceptual)
             if not last_entity:
-                return extra_info, None
-            merged_info = MergeConceptualDataModels(extra_info).transform(last_entity.conceptual)
+                return extra_conceptual, None
+            merged_conceptual = MergeConceptualDataModels(extra_conceptual).transform(last_entity.conceptual)
             if not last_entity.physical:
-                return merged_info, None
+                return merged_conceptual, None
 
-            extra_dms = ConceptualToPhysical(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 = MergePhysicalDataModels(extra_dms).transform(last_entity.physical)
-            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 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:

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_physical_data_model
+        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_physical_data_model.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,9 +62,9 @@ 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
+        last_entity = self._state.data_model_store.provenance[-1].target_entity
         if last_entity.physical:
             df = last_entity.physical.properties.to_pandas()
         else:
@@ -73,9 +73,9 @@ class InspectAPI:
         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
+        last_entity = self._state.data_model_store.provenance[-1].target_entity
         if last_entity.physical is None:
             return pd.DataFrame()
         df = last_entity.physical.views.to_pandas()
@@ -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

@@ -42,12 +42,12 @@ 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 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.physical
+        data_model = last_entity.physical
         if self._state.client is None:
             raise NeatSessionError("Client is required to map classic to core")
 
@@ -57,7 +57,11 @@ class DataModelMappingAPI:
         transformers.extend(
             [
                 PhysicalDataModelMapper(
-                    load_classic_to_core_mapping(company_prefix, rules.metadata.space, rules.metadata.version)
+                    load_classic_to_core_mapping(
+                        company_prefix,
+                        data_model.metadata.space,
+                        data_model.metadata.version,
+                    )
                 ),
                 IncludeReferenced(self._state.client),
             ]