cognite-neat 0.103.1__py3-none-any.whl → 0.105.0__py3-none-any.whl

cognite/neat/_rules/transformers/_mapping.py

@@ -1,19 +1,17 @@
 import warnings
 from abc import ABC
 from collections import defaultdict
-from functools import cached_property
 from typing import Any, ClassVar, Literal
 
 from cognite.client import data_modeling as dm
 
 from cognite.neat._client import NeatClient
 from cognite.neat._issues.errors import CDFMissingClientError, NeatValueError, ResourceNotFoundError
-from cognite.neat._issues.warnings import NeatValueWarning, PropertyOverwritingWarning
-from cognite.neat._rules._shared import JustRules, OutRules
+from cognite.neat._issues.warnings import PropertyOverwritingWarning
 from cognite.neat._rules.models import DMSRules, SheetList
 from cognite.neat._rules.models.data_types import Enum
-from cognite.neat._rules.models.dms import DMSEnum, DMSProperty, DMSView
-from cognite.neat._rules.models.entities import ContainerEntity, ViewEntity
+from cognite.neat._rules.models.dms import DMSContainer, DMSEnum, DMSProperty
+from cognite.neat._rules.models.entities import ClassEntity, ContainerEntity, ViewEntity
 
 from ._base import RulesTransformer
 
@@ -55,8 +53,8 @@ class MapOneToOne(MapOntoTransformers):
         self.view_extension_mapping = view_extension_mapping
         self.default_extension = default_extension
 
-    def transform(self, rules: DMSRules | OutRules[DMSRules]) -> JustRules[DMSRules]:
-        solution: DMSRules = self._to_rules(rules)
+    def transform(self, rules: DMSRules) -> DMSRules:
+        solution: DMSRules = rules
         view_by_external_id = {view.view.external_id: view for view in solution.views}
         ref_view_by_external_id = {view.view.external_id: view for view in self.reference.views}
 
@@ -99,17 +97,18 @@ class MapOneToOne(MapOntoTransformers):
                     prop.container = ref_prop.container
                     prop.container_property = ref_prop.container_property
 
-        return JustRules(solution)
+        return solution
 
 
 class RuleMapper(RulesTransformer[DMSRules, DMSRules]):
     """Maps properties and classes using the given mapping.
 
-    **Note**: This transformer mutates the input rules.
-
     Args:
-        mapping: The mapping to use.
-
+        mapping: The mapping to use represented as a DMSRules object.
+        data_type_conflict: How to handle data type conflicts. The default is "overwrite".
+            A data type conflicts occurs when the data type of a property in the mapping is different from the
+            data type of the property in the input rules. If "overwrite" the data type in the input rules is overwritten
+            with the data type in the mapping.
     """
 
     _mapping_fields: ClassVar[frozenset[str]] = frozenset(
@@ -120,70 +119,85 @@ class RuleMapper(RulesTransformer[DMSRules, DMSRules]):
         self.mapping = mapping
         self.data_type_conflict = data_type_conflict
 
-    @cached_property
-    def _view_by_entity_id(self) -> dict[str, DMSView]:
-        return {view.view.external_id: view for view in self.mapping.views}
-
-    @cached_property
-    def _property_by_view_property(self) -> dict[tuple[str, str], DMSProperty]:
-        return {(prop.view.external_id, prop.view_property): prop for prop in self.mapping.properties}
-
-    def transform(self, rules: DMSRules | OutRules[DMSRules]) -> JustRules[DMSRules]:
+    def transform(self, rules: DMSRules) -> DMSRules:
         if self.data_type_conflict != "overwrite":
             raise NeatValueError(f"Invalid data_type_conflict: {self.data_type_conflict}")
-        input_rules = self._to_rules(rules)
+        input_rules = rules
         new_rules = input_rules.model_copy(deep=True)
-        new_rules.metadata.version += "_mapped"
 
-        for view in new_rules.views:
-            if mapping_view := self._view_by_entity_id.get(view.view.external_id):
-                view.implements = mapping_view.implements
-
-        for prop in new_rules.properties:
-            key = (prop.view.external_id, prop.view_property)
-            if key not in self._property_by_view_property:
-                continue
-            mapping_prop = self._property_by_view_property[key]
-            to_overwrite, conflicts = self._find_overwrites(prop, mapping_prop)
-            if conflicts and self.data_type_conflict == "overwrite":
-                warnings.warn(
-                    PropertyOverwritingWarning(prop.view.as_id(), "view", prop.view_property, tuple(conflicts)),
-                    stacklevel=2,
-                )
-            elif conflicts:
-                raise NeatValueError(f"Conflicting properties for {prop.view}.{prop.view_property}: {conflicts}")
-            for field_name, value in to_overwrite.items():
-                setattr(prop, field_name, value)
-            prop.container = mapping_prop.container
-            prop.container_property = mapping_prop.container_property
-
-        # Add missing views used as value types
-        existing_views = {view.view for view in new_rules.views}
-        new_value_types = {
-            prop.value_type
-            for prop in new_rules.properties
-            if isinstance(prop.value_type, ViewEntity) and prop.value_type not in existing_views
-        }
-        for new_value_type in new_value_types:
-            if mapping_view := self._view_by_entity_id.get(new_value_type.external_id):
-                new_rules.views.append(mapping_view)
+        views_by_external_id = {view.view.external_id: view for view in new_rules.views}
+        new_views: set[ViewEntity] = set()
+        for mapping_view in self.mapping.views:
+            if existing_view := views_by_external_id.get(mapping_view.view.external_id):
+                existing_view.implements = mapping_view.implements
             else:
-                warnings.warn(NeatValueWarning(f"View {new_value_type} not found in mapping"), stacklevel=2)
+                # We need to add all the views in the mapping that are not in the input rules.
+                # This is to ensure that all ValueTypes are present in the resulting rules.
+                # For example, if a property is a direct relation to an Equipment view, we need to add
+                # the Equipment view to the rules.
+                new_rules.views.append(mapping_view)
+                new_views.add(mapping_view.view)
 
-        # Add missing enums
-        existing_enum_collections = {item.collection for item in new_rules.enum or []}
-        new_enums = {
-            prop.value_type.collection
-            for prop in new_rules.properties
-            if isinstance(prop.value_type, Enum) and prop.value_type.collection not in existing_enum_collections
+        properties_by_view_property = {
+            (prop.view.external_id, prop.view_property): prop for prop in new_rules.properties
         }
-        if new_enums:
-            new_rules.enum = new_rules.enum or SheetList[DMSEnum]([])
-            for item in self.mapping.enum or []:
-                if item.collection in new_enums:
-                    new_rules.enum.append(item)
+        existing_enum_collections = {item.collection for item in new_rules.enum or []}
+        mapping_enums_by_collection: dict[ClassEntity, list[DMSEnum]] = defaultdict(list)
+        for item in self.mapping.enum or []:
+            mapping_enums_by_collection[item.collection].append(item)
+        existing_containers = {container.container for container in new_rules.containers or []}
+        mapping_containers_by_id = {container.container: container for container in self.mapping.containers or []}
+        for mapping_prop in self.mapping.properties:
+            if existing_prop := properties_by_view_property.get(
+                (mapping_prop.view.external_id, mapping_prop.view_property)
+            ):
+                to_overwrite, conflicts = self._find_overwrites(existing_prop, mapping_prop)
+                if conflicts and self.data_type_conflict == "overwrite":
+                    warnings.warn(
+                        PropertyOverwritingWarning(
+                            existing_prop.view.as_id(), "view", existing_prop.view_property, tuple(conflicts)
+                        ),
+                        stacklevel=2,
+                    )
+                elif conflicts:
+                    raise NeatValueError(
+                        f"Conflicting properties for {existing_prop.view}.{existing_prop.view_property}: {conflicts}"
+                    )
+
+                for field_name, value in to_overwrite.items():
+                    setattr(existing_prop, field_name, value)
+                existing_prop.container = mapping_prop.container
+                existing_prop.container_property = mapping_prop.container_property
+            elif isinstance(mapping_prop.value_type, ViewEntity):
+                # All connections must be included in the rules. This is to update the
+                # ValueTypes of the implemented views.
+                new_rules.properties.append(mapping_prop)
+            elif mapping_prop.view in new_views:
+                # All properties of new views are included. Main motivation is GUIDs properties
+                new_rules.properties.append(mapping_prop)
+            else:
+                # Skipping mapped properties that are not in the input rules.
+                continue
 
-        return JustRules(new_rules)
+            if (
+                isinstance(mapping_prop.value_type, Enum)
+                and mapping_prop.value_type.collection not in existing_enum_collections
+            ):
+                if not new_rules.enum:
+                    new_rules.enum = SheetList[DMSEnum]([])
+                new_rules.enum.extend(mapping_enums_by_collection[mapping_prop.value_type.collection])
+
+            if (
+                mapping_prop.container
+                and mapping_prop.container not in existing_containers
+                and (new_container := mapping_containers_by_id.get(mapping_prop.container))
+            ):
+                # Mapping can include new containers for GUID properties
+                if not new_rules.containers:
+                    new_rules.containers = SheetList[DMSContainer]([])
+                new_rules.containers.append(new_container)
+
+        return new_rules
 
     def _find_overwrites(self, prop: DMSProperty, mapping_prop: DMSProperty) -> tuple[dict[str, Any], list[str]]:
         """Finds the properties that need to be overwritten and returns them.
@@ -212,6 +226,10 @@ class RuleMapper(RulesTransformer[DMSRules, DMSRules]):
                     conflicts.append(mapping_prop.model_fields[field_name].alias or field_name)
         return to_overwrite, conflicts
 
+    @property
+    def description(self) -> str:
+        return f"Mapping to {self.mapping.metadata.as_data_model_id()!r}."
+
 
 class AsParentPropertyId(RulesTransformer[DMSRules, DMSRules]):
     """Looks up all view properties that map to the same container property,
@@ -221,10 +239,9 @@ class AsParentPropertyId(RulesTransformer[DMSRules, DMSRules]):
     def __init__(self, client: NeatClient | None = None) -> None:
         self._client = client
 
-    def transform(self, rules: DMSRules | OutRules[DMSRules]) -> JustRules[DMSRules]:
-        input_rules = self._to_rules(rules)
+    def transform(self, rules: DMSRules) -> DMSRules:
+        input_rules = rules
         new_rules = input_rules.model_copy(deep=True)
-        new_rules.metadata.version += "_as_parent_name"
 
         path_by_view = self._inheritance_path_by_view(new_rules)
         view_by_container_property = self._view_by_container_properties(new_rules)
@@ -240,7 +257,7 @@ class AsParentPropertyId(RulesTransformer[DMSRules, DMSRules]):
                 ):
                     prop.view_property = parent_name
 
-        return JustRules(new_rules)
+        return new_rules
 
     # Todo: Move into Probe class. Note this means that the Probe class must take a NeatClient as an argument.
     def _inheritance_path_by_view(self, rules: DMSRules) -> dict[ViewEntity, list[ViewEntity]]:
@@ -338,3 +355,7 @@ class AsParentPropertyId(RulesTransformer[DMSRules, DMSRules]):
             _, prop_name = min(view_properties, key=lambda prop: len(path_by_view[prop[0]]))
             parent_name_by_container_property[(container, container_property)] = prop_name
         return parent_name_by_container_property
+
+    @property
+    def description(self) -> str:
+        return "Renaming property names to parent name"

cognite/neat/_rules/transformers/_verification.py

@@ -1,14 +1,11 @@
 from abc import ABC
-from typing import Any, Literal
 
-from cognite.neat._issues import IssueList, MultiValueError, NeatError, NeatWarning, catch_issues
-from cognite.neat._issues.errors import NeatTypeError
+from cognite.neat._client import NeatClient
+from cognite.neat._issues import MultiValueError, catch_issues
+from cognite.neat._issues.errors import NeatTypeError, NeatValueError
 from cognite.neat._rules._shared import (
-    InputRules,
-    MaybeRules,
-    OutRules,
     ReadRules,
-    T_InputRules,
+    T_ReadInputRules,
     T_VerifiedRules,
     VerifiedRules,
 )
@@ -24,78 +21,93 @@ from cognite.neat._rules.models.information import InformationValidation
 from ._base import RulesTransformer
 
 
-class VerificationTransformer(RulesTransformer[T_InputRules, T_VerifiedRules], ABC):
+class VerificationTransformer(RulesTransformer[T_ReadInputRules, T_VerifiedRules], ABC):
     """Base class for all verification transformers."""
 
     _rules_cls: type[T_VerifiedRules]
     _validation_cls: type
 
-    def __init__(self, errors: Literal["raise", "continue"], validate: bool = True) -> None:
-        self.errors = errors
+    def __init__(self, validate: bool = True, client: NeatClient | None = None) -> None:
         self.validate = validate
+        self._client = client
 
-    def transform(self, rules: T_InputRules | OutRules[T_InputRules]) -> MaybeRules[T_VerifiedRules]:
-        issues = IssueList()
-        in_: T_InputRules = self._to_rules(rules)
-        error_args: dict[str, Any] = {}
-        if isinstance(rules, ReadRules):
-            error_args = rules.read_context
+    def transform(self, rules: T_ReadInputRules) -> T_VerifiedRules:
+        in_ = rules.rules
+        if in_ is None:
+            raise NeatValueError("Cannot verify rules. The reading of the rules failed.")
+        error_args = rules.read_context
         verified_rules: T_VerifiedRules | None = None
-        with catch_issues(issues, NeatError, NeatWarning, error_args) as future:
-            rules_cls = self._get_rules_cls(in_)
+        # 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 o
+        with catch_issues(error_args=error_args) as issues:
+            rules_cls = self._get_rules_cls(rules)
             dumped = in_.dump()
             verified_rules = rules_cls.model_validate(dumped)  # type: ignore[assignment]
             if self.validate:
                 validation_cls = self._get_validation_cls(verified_rules)  # type: ignore[arg-type]
-                validation_issues = validation_cls(verified_rules).validate()
-                # We need to trigger warnings are raise exceptions such that they are caught by the context manager
-                # and processed with the read context
-                if validation_issues.warnings:
-                    validation_issues.trigger_warnings()
+                if issubclass(validation_cls, DMSValidation):
+                    validation_issues = DMSValidation(verified_rules, self._client).validate()  # type: ignore[arg-type]
+                elif issubclass(validation_cls, InformationValidation):
+                    validation_issues = InformationValidation(verified_rules).validate()  # type: ignore[arg-type]
+                else:
+                    raise NeatValueError("Unsupported rule type")
+
+                # Need to trigger and raise such that the catch_issues can add the extra context
+                validation_issues.trigger_warnings()
                 if validation_issues.has_errors:
-                    verified_rules = None
                     raise MultiValueError(validation_issues.errors)
 
-        if (future.result == "failure" or issues.has_errors or verified_rules is None) and self.errors == "raise":
-            raise issues.as_errors()
-        return MaybeRules[T_VerifiedRules](
-            rules=verified_rules,
-            issues=issues,
-        )
+        # Raise issues which is expected to be handled outside of this method
+        issues.trigger_warnings()
+        if issues.has_errors:
+            raise MultiValueError(issues.errors)
+        if verified_rules is None:
+            raise NeatValueError("Rules were not verified")
+        return verified_rules
 
-    def _get_rules_cls(self, in_: T_InputRules) -> type[T_VerifiedRules]:
+    def _get_rules_cls(self, in_: T_ReadInputRules) -> type[T_VerifiedRules]:
         return self._rules_cls
 
     def _get_validation_cls(self, rules: T_VerifiedRules) -> type:
         return self._validation_cls
 
+    @property
+    def description(self) -> str:
+        return "Verify rules"
 
-class VerifyDMSRules(VerificationTransformer[DMSInputRules, DMSRules]):
+
+class VerifyDMSRules(VerificationTransformer[ReadRules[DMSInputRules], DMSRules]):
     """Class to verify DMS rules."""
 
     _rules_cls = DMSRules
     _validation_cls = DMSValidation
 
+    def transform(self, rules: ReadRules[DMSInputRules]) -> DMSRules:
+        return super().transform(rules)
+
 
-class VerifyInformationRules(VerificationTransformer[InformationInputRules, InformationRules]):
+class VerifyInformationRules(VerificationTransformer[ReadRules[InformationInputRules], InformationRules]):
     """Class to verify Information rules."""
 
     _rules_cls = InformationRules
     _validation_cls = InformationValidation
 
+    def transform(self, rules: ReadRules[InformationInputRules]) -> InformationRules:
+        return super().transform(rules)
 
-class VerifyAnyRules(VerificationTransformer[InputRules, VerifiedRules]):
+
+class VerifyAnyRules(VerificationTransformer[T_ReadInputRules, VerifiedRules]):
     """Class to verify arbitrary rules"""
 
-    def _get_rules_cls(self, in_: InputRules) -> type[VerifiedRules]:
-        if isinstance(in_, InformationInputRules):
+    def _get_rules_cls(self, in_: T_ReadInputRules) -> type[VerifiedRules]:
+        if isinstance(in_.rules, InformationInputRules):
             return InformationRules
-        elif isinstance(in_, DMSInputRules):
+        elif isinstance(in_.rules, DMSInputRules):
             return DMSRules
         else:
             raise NeatTypeError(f"Unsupported rules type: {type(in_)}")
 
-    def _get_validation_cls(self, rules: T_VerifiedRules) -> type:
+    def _get_validation_cls(self, rules: VerifiedRules) -> type:
         if isinstance(rules, InformationRules):
             return InformationValidation
         elif isinstance(rules, DMSRules):

cognite/neat/_session/_base.py

@@ -1,26 +1,17 @@
-from datetime import datetime, timezone
-from typing import Literal, cast
+from typing import Literal
 
 from cognite.client import CogniteClient
 from cognite.client import data_modeling as dm
 
 from cognite.neat import _version
 from cognite.neat._client import NeatClient
-from cognite.neat._issues import IssueList, catch_issues
+from cognite.neat._issues import IssueList
 from cognite.neat._issues.errors import RegexViolationError
 from cognite.neat._rules import importers
-from cognite.neat._rules._shared import ReadRules, VerifiedRules
-from cognite.neat._rules.models import DMSRules
-from cognite.neat._rules.models.dms import DMSValidation
-from cognite.neat._rules.models.information import InformationValidation
+from cognite.neat._rules.models._base_input import InputRules
 from cognite.neat._rules.models.information._rules import InformationRules
-from cognite.neat._rules.models.information._rules_input import InformationInputRules
 from cognite.neat._rules.transformers import ConvertToRules, InformationToDMS, VerifyAnyRules
 from cognite.neat._rules.transformers._converters import ConversionTransformer
-from cognite.neat._store._provenance import (
-    INSTANCES_ENTITY,
-    Change,
-)
 
 from ._collector import _COLLECTOR, Collector
 from ._drop import DropAPI
@@ -128,47 +119,16 @@ class NeatSession:
             neat.verify()
             ```
         """
-        source_id, last_unverified_rule = self._state.data_model.last_unverified_rule
-        transformer = VerifyAnyRules("continue", validate=False)
-        start = datetime.now(timezone.utc)
-        output = transformer.try_transform(last_unverified_rule)
-
-        if output.rules:
-            if isinstance(output.rules, DMSRules):
-                issues = DMSValidation(output.rules, self._client).validate()
-            elif isinstance(output.rules, InformationRules):
-                issues = InformationValidation(output.rules).validate()
-            else:
-                raise NeatSessionError("Unsupported rule type")
-            if issues.has_errors:
-                # This is up for discussion, but I think we should not return rules that
-                # only pass the verification but not the validation.
-                output.rules = None
-            output.issues.extend(issues)
-
-            end = datetime.now(timezone.utc)
-
-            if output.rules:
-                change = Change.from_rules_activity(
-                    output.rules,
-                    transformer.agent,
-                    start,
-                    end,
-                    f"Verified data model {source_id} as {output.rules.metadata.identifier}",
-                    self._state.data_model.provenance.source_entity(source_id)
-                    or self._state.data_model.provenance.target_entity(source_id),
-                )
-
-                self._state.data_model.write(output.rules, change)
-
-                if isinstance(output.rules, InformationRules):
-                    self._state.instances.store.add_rules(output.rules)
-
-        output.issues.action = "verify"
-        self._state.data_model.issue_lists.append(output.issues)
-        if output.issues:
+        transformer = VerifyAnyRules(validate=True, client=self._client)  # type: ignore[var-annotated]
+        issues = self._state.rule_transform(transformer)
+        if not issues.has_errors:
+            rules = self._state.rule_store.last_verified_rule
+            if isinstance(rules, InformationRules):
+                self._state.instances.store.add_rules(rules)
+
+        if issues:
             print("You can inspect the issues with the .inspect.issues(...) method.")
-        return output.issues
+        return issues
 
     def convert(
         self, target: Literal["dms", "information"], mode: Literal["edge_properties"] | None = None
@@ -192,43 +152,17 @@ class NeatSession:
             neat.convert(target="information")
             ```
         """
-        start = datetime.now(timezone.utc)
-        issues = IssueList()
-        converter: ConversionTransformer | None = None
-        converted_rules: VerifiedRules | None = None
-        with catch_issues(issues):
-            if target == "dms":
-                source_id, info_rules = self._state.data_model.last_verified_information_rules
-                converter = InformationToDMS(mode=mode)
-                converted_rules = converter.transform(info_rules).rules
-            elif target == "information":
-                source_id, dms_rules = self._state.data_model.last_verified_dms_rules
-                converter = ConvertToRules(InformationRules)
-                converted_rules = converter.transform(dms_rules).rules
-            else:
-                # Session errors are not caught by the catch_issues context manager
-                raise NeatSessionError(f"Target {target} not supported.")
-
-        end = datetime.now(timezone.utc)
-        if issues:
-            self._state.data_model.issue_lists.append(issues)
-
-        if converted_rules is not None and converter is not None:
-            # Provenance
-            change = Change.from_rules_activity(
-                converted_rules,
-                converter.agent,
-                start,
-                end,
-                f"Converted data model {source_id} to {converted_rules.metadata.identifier}",
-                self._state.data_model.provenance.source_entity(source_id)
-                or self._state.data_model.provenance.target_entity(source_id),
-            )
-
-            self._state.data_model.write(converted_rules, change)
-
-            if self._verbose and not issues.has_errors:
-                print(f"Rules converted to {target}")
+        converter: ConversionTransformer
+        if target == "dms":
+            converter = InformationToDMS(mode=mode)
+        elif target == "information":
+            converter = ConvertToRules(InformationRules)
+        else:
+            raise NeatSessionError(f"Target {target} not supported.")
+        issues = self._state.rule_transform(converter)
+
+        if self._verbose and not issues.has_errors:
+            print(f"Rules converted to {target}")
         else:
             print("Conversion failed.")
         if issues:
@@ -263,53 +197,30 @@ class NeatSession:
             ```
         """
         model_id = dm.DataModelId.load(model_id)
-
-        start = datetime.now(timezone.utc)
         importer = importers.InferenceImporter.from_graph_store(
             store=self._state.instances.store,
             max_number_of_instance=max_number_of_instance,
+            data_model_id=model_id,
         )
-        inferred_rules: ReadRules = importer.to_rules()
-        end = datetime.now(timezone.utc)
-
-        if model_id.space:
-            cast(InformationInputRules, inferred_rules.rules).metadata.space = model_id.space
-        if model_id.external_id:
-            cast(InformationInputRules, inferred_rules.rules).metadata.external_id = model_id.external_id
-
-        if model_id.version:
-            cast(InformationInputRules, inferred_rules.rules).metadata.version = model_id.version
-
-        # Provenance
-        change = Change.from_rules_activity(
-            inferred_rules,
-            importer.agent,
-            start,
-            end,
-            "Inferred data model",
-            INSTANCES_ENTITY,
-        )
-
-        self._state.data_model.write(inferred_rules, change)
-        return inferred_rules.issues
+        return self._state.rule_import(importer)
 
     def _repr_html_(self) -> str:
         state = self._state
         if (
             not state.instances.has_store
-            and not state.data_model.has_unverified_rules
-            and not state.data_model.has_verified_rules
+            and not state.rule_store.has_unverified_rules
+            and not state.rule_store.has_verified_rules
         ):
             return "<strong>Empty session</strong>. Get started by reading something with the <em>.read</em> attribute."
 
         output = []
 
-        if state.data_model.has_unverified_rules and not state.data_model.has_verified_rules:
-            rules: ReadRules = state.data_model.last_unverified_rule[1]
-            output.append(f"<H2>Unverified Data Model</H2><br />{rules.rules._repr_html_()}")  # type: ignore
+        if state.rule_store.has_unverified_rules and not state.rule_store.has_verified_rules:
+            rules: InputRules = state.rule_store.last_unverified_rule
+            output.append(f"<H2>Unverified Data Model</H2><br />{rules._repr_html_()}")  # type: ignore
 
-        if state.data_model.has_verified_rules:
-            output.append(f"<H2>Verified Data Model</H2><br />{state.data_model.last_verified_rule[1]._repr_html_()}")  # type: ignore
+        if state.rule_store.has_verified_rules:
+            output.append(f"<H2>Verified Data Model</H2><br />{state.rule_store.last_verified_rule._repr_html_()}")  # type: ignore
 
         if state.instances.has_store:
             output.append(f"<H2>Instances</H2> {state.instances.store._repr_html_()}")

cognite/neat/_session/_inspect.py

@@ -59,7 +59,9 @@ class InspectAPI:
             neat.inspect.properties
             ```
         """
-        return self._state.data_model.last_verified_rule[1].properties.to_pandas()
+        df = self._state.rule_store.last_verified_rule.properties.to_pandas()
+        df.drop(columns=["neatId"], errors="ignore", inplace=True)
+        return df
 
 
 @session_class_wrapper
@@ -89,7 +91,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.data_model.last_issues
+        issues = self._state.rule_store.last_issues
         if not issues:
             self._print("No issues found.")
 
@@ -141,7 +143,7 @@ class InspectOutcome:
     """
 
     def __init__(self, state: SessionState) -> None:
-        self.data_model = InspectUploadOutcome(lambda: state.data_model.last_outcome)
+        self.data_model = InspectUploadOutcome(lambda: state.rule_store.last_outcome)
         self.instances = InspectUploadOutcome(lambda: state.instances.last_outcome)