cognite-neat 0.107.0__py3-none-any.whl → 0.109.0__py3-none-any.whl

cognite/neat/_session/_show.py

@@ -98,22 +98,15 @@ class ShowDataModelAPI(ShowBaseAPI):
         self.implements = ShowDataModelImplementsAPI(self._state)
 
     def __call__(self) -> Any:
-        if not self._state.rule_store.has_verified_rules:
-            raise NeatSessionError(
-                "No verified data model available. Try using [bold].verify()[/bold] to verify data model."
-            )
-
-        rules = self._state.rule_store.last_verified_rule
+        if self._state.rule_store.empty:
+            raise NeatSessionError("No data model available. Try using [bold].read[/bold] to read a new data model.")
+        last_target = self._state.rule_store.provenance[-1].target_entity
+        rules = last_target.dms or last_target.information
 
-        if isinstance(rules, DMSRules):
-            di_graph = self._generate_dms_di_graph(rules)
-        elif isinstance(rules, InformationRules):
-            di_graph = self._generate_info_di_graph(rules)
+        if last_target.dms is not None:
+            di_graph = self._generate_dms_di_graph(last_target.dms)
         else:
-            # This should never happen, but we need to handle it to satisfy mypy
-            raise NeatSessionError(
-                f"Unsupported type {type(rules) }. Make sure you have either information or DMS rules."
-            )
+            di_graph = self._generate_info_di_graph(last_target.information)
         identifier = to_directory_compatible(str(rules.metadata.identifier))
         name = f"{identifier}.html"
 
@@ -187,22 +180,16 @@ class ShowDataModelImplementsAPI(ShowBaseAPI):
         self._state = state
 
     def __call__(self) -> Any:
-        if not self._state.rule_store.has_verified_rules:
-            raise NeatSessionError(
-                "No verified data model available. Try using [bold].verify()[/bold] to verify data model."
-            )
+        if self._state.rule_store.empty:
+            raise NeatSessionError("No data model available. Try using [bold].read[/bold] to read a data model.")
 
-        rules = self._state.rule_store.last_verified_rule
+        last_target = self._state.rule_store.provenance[-1].target_entity
+        rules = last_target.dms or last_target.information
 
-        if isinstance(rules, DMSRules):
-            di_graph = self._generate_dms_di_graph(rules)
-        elif isinstance(rules, InformationRules):
-            di_graph = self._generate_info_di_graph(rules)
+        if last_target.dms is not None:
+            di_graph = self._generate_dms_di_graph(last_target.dms)
         else:
-            # This should never happen, but we need to handle it to satisfy mypy
-            raise NeatSessionError(
-                f"Unsupported type {type(rules) }. Make sure you have either information or DMS rules."
-            )
+            di_graph = self._generate_info_di_graph(last_target.information)
         identifier = to_directory_compatible(str(rules.metadata.identifier))
         name = f"{identifier}_implements.html"
         return self._generate_visualization(di_graph, name)
@@ -325,20 +312,6 @@ class ShowDataModelProvenanceAPI(ShowBaseAPI):
                 )
                 di_graph.add_edge(source_shorten, export_id, label="exported", color="grey")
 
-        for pruned_lists in self._state.rule_store.pruned_by_source_entity_id.values():
-            for prune_path in pruned_lists:
-                for change in prune_path:
-                    source = uri_display_name(change.source_entity.id_)
-                    target = uri_display_name(change.target_entity.id_)
-                    di_graph.add_node(
-                        target,
-                        label=target,
-                        type="Pruned",
-                        title="Pruned",
-                        color=hex_colored_types["Pruned"],
-                    )
-                    di_graph.add_edge(source, target, label="pruned", color="grey")
-
         return di_graph
 
 
@@ -364,7 +337,7 @@ class ShowInstanceAPI(ShowBaseAPI):
                 'Try setting [bold]NeatSession(storage="oxigraph")[/bold] enable Oxigraph store.'
             )
 
-        if not self._state.instances.store.graph:
+        if not self._state.instances.store.dataset:
             raise NeatSessionError("No instances available. Try using [bold].read[/bold] to load instances.")
 
         di_graph = self._generate_instance_di_graph_and_types()
@@ -395,7 +368,7 @@ class ShowInstanceAPI(ShowBaseAPI):
             object,
             subject_type,
             object_type,
-        ) in self._state.instances.store.graph.query(query):
+        ) in self._state.instances.store.dataset.query(query):
             subject = remove_namespace_from_uri(subject)
             property_ = remove_namespace_from_uri(property_)
             object = remove_namespace_from_uri(object)

cognite/neat/_session/_state.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass, field
+from pathlib import Path
 from typing import Literal, cast
 
 from cognite.neat._client import NeatClient
@@ -6,55 +6,46 @@ from cognite.neat._graph.extractors import KnowledgeGraphExtractor
 from cognite.neat._issues import IssueList
 from cognite.neat._rules.importers import BaseImporter, InferenceImporter
 from cognite.neat._rules.models import DMSRules, InformationRules
-from cognite.neat._rules.transformers import RulesTransformer, ToExtensionModel
+from cognite.neat._rules.transformers import (
+    VerifiedRulesTransformer,
+)
 from cognite.neat._store import NeatGraphStore, NeatRulesStore
-from cognite.neat._store._rules_store import ModelEntity
-from cognite.neat._utils.rdf_ import uri_display_name
-from cognite.neat._utils.text import humanize_collection
 from cognite.neat._utils.upload import UploadResultList
 
-from .exceptions import NeatSessionError
+from .exceptions import NeatSessionError, _session_method_wrapper
 
 
 class SessionState:
-    def __init__(self, store_type: Literal["memory", "oxigraph"], client: NeatClient | None = None) -> None:
-        self.instances = InstancesState(store_type)
+    def __init__(
+        self,
+        store_type: Literal["memory", "oxigraph"],
+        storage_path: Path | None = None,
+        client: NeatClient | None = None,
+    ) -> None:
+        self.instances = InstancesState(store_type, storage_path=storage_path)
         self.rule_store = NeatRulesStore()
         self.last_reference: DMSRules | InformationRules | None = None
         self.client = client
+        self.quoted_source_identifiers = False
 
-    def rule_transform(self, *transformer: RulesTransformer) -> IssueList:
+    def rule_transform(self, *transformer: VerifiedRulesTransformer) -> IssueList:
         if not transformer:
             raise NeatSessionError("No transformers provided.")
-        first_transformer = transformer[0]
-        pruned = self.rule_store.prune_until_compatible(first_transformer)
-        if pruned:
-            type_hint = first_transformer.transform_type_hint()
-            action = uri_display_name(first_transformer.agent.id_)
-            location = cast(ModelEntity, self.rule_store.provenance[-1].target_entity).display_name
-            expected = humanize_collection([hint.display_type_name() for hint in type_hint])  # type: ignore[attr-defined]
-            step_str = "step" if len(pruned) == 1 else "steps"
-            print(
-                f"The {action} actions expects a {expected}. "
-                f"Moving back {len(pruned)} {step_str} to the last {location}."
-            )
-        if (
-            any(isinstance(t, ToExtensionModel) for t in transformer)
-            and isinstance(self.rule_store.provenance[-1].target_entity, ModelEntity)
-            and isinstance(self.rule_store.provenance[-1].target_entity.result, DMSRules | InformationRules)
-        ):
-            self.last_reference = self.rule_store.provenance[-1].target_entity.result
 
-        start = cast(ModelEntity, self.rule_store.provenance[-1].target_entity).display_name
+        start = self.rule_store.provenance[-1].target_entity.display_name
         issues = self.rule_store.transform(*transformer)
-        end = cast(ModelEntity, self.rule_store.provenance[-1].target_entity).display_name
-        issues.action = f"{start} → {end}"
+        last_entity = self.rule_store.provenance[-1].target_entity
+        issues.action = f"{start} → {last_entity.display_name}"
         issues.hint = "Use the .inspect.issues() for more details."
+        self.instances.store.add_rules(last_entity.information)
         return issues
 
     def rule_import(self, importer: BaseImporter) -> IssueList:
-        issues = self.rule_store.import_(importer)
-        result = cast(ModelEntity, self.rule_store.provenance[-1].target_entity).display_name
+        issues = self.rule_store.import_rules(importer, client=self.client)
+        if self.rule_store.empty:
+            result = "failed"
+        else:
+            result = self.rule_store.provenance[-1].target_entity.display_name
         if isinstance(importer, InferenceImporter):
             issues.action = f"Inferred {result}"
         else:
@@ -64,36 +55,46 @@ class SessionState:
         return issues
 
     def write_graph(self, extractor: KnowledgeGraphExtractor) -> IssueList:
-        self.instances.store.write(extractor)
-        issue_list = self.rule_store.import_graph(extractor)
+        extract_issues = self.instances.store.write(extractor)
+        issues = self.rule_store.import_graph(extractor)
         self.instances.store.add_rules(self.rule_store.last_verified_information_rules)
-        return issue_list
+        issues.extend(extract_issues)
+        return issues
 
 
-@dataclass
 class InstancesState:
-    store_type: Literal["memory", "oxigraph"]
-    issue_lists: list[IssueList] = field(default_factory=list)
-    outcome: list[UploadResultList] = field(default_factory=list)
-    _store: NeatGraphStore | None = field(init=False, default=None)
+    def __init__(
+        self,
+        store_type: Literal["memory", "oxigraph"],
+        storage_path: Path | None = None,
+    ) -> None:
+        self.store_type = store_type
+        self.storage_path = storage_path
+        self.issue_lists = IssueList()
+        self.outcome = UploadResultList()
 
-    @property
-    def store(self) -> NeatGraphStore:
-        if not self.has_store:
-            if self.store_type == "oxigraph":
-                self._store = NeatGraphStore.from_oxi_store()
-            else:
-                self._store = NeatGraphStore.from_memory_store()
-        return cast(NeatGraphStore, self._store)
+        # Ensure that error handling is done in the constructor
+        self.store = _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:
+        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)
+        else:
+            return NeatGraphStore.from_memory_store()
 
     @property
-    def has_store(self) -> bool:
-        return self._store is not None
+    def empty(self) -> bool:
+        return self.store.empty
 
     @property
     def last_outcome(self) -> UploadResultList:
         if not self.outcome:
             raise NeatSessionError(
-                "No outcome available. Try using [bold].to.cdf.instances[/bold] to upload a data minstances."
+                "No outcome available. Try using [bold].to.cdf.instances[/bold] to upload a data instance."
             )
-        return self.outcome[-1]
+        return cast(UploadResultList, self.outcome[-1])

cognite/neat/_session/_to.py

@@ -4,7 +4,7 @@ from collections.abc import Collection
 from pathlib import Path
 from typing import Any, Literal, overload
 
-from cognite.client.data_classes.data_modeling import SpaceApply
+from cognite.client import data_modeling as dm
 
 from cognite.neat._constants import COGNITE_MODELS
 from cognite.neat._graph import loaders
@@ -104,7 +104,7 @@ class ToAPI:
 
         with zipfile.ZipFile(filepath, "w") as zip_ref:
             zip_ref.writestr(
-                "neat-session/instances/instances.ttl",
+                "neat-session/instances/instances.trig",
                 self._state.instances.store.serialize(),
             )
 
@@ -194,7 +194,10 @@ class CDFToAPI:
         self._state = state
         self._verbose = verbose
 
-    def instances(self, space: str | None = None) -> UploadResultList:
+    def instances(
+        self,
+        space: str | None = None,
+    ) -> UploadResultList:
         """Export the verified DMS instances to CDF.
 
         Args:
@@ -213,14 +216,18 @@ class CDFToAPI:
             raise NeatSessionError("Please provide a valid space name. {PATTERNS.space_compliance.pattern}")
 
         if not client.data_modeling.spaces.retrieve(space):
-            client.data_modeling.spaces.apply(SpaceApply(space=space))
+            client.data_modeling.spaces.apply(dm.SpaceApply(space=space))
 
         loader = loaders.DMSLoader.from_rules(
             self._state.rule_store.last_verified_dms_rules,
             self._state.instances.store,
             instance_space=space,
             client=client,
+            # In case urllib.parse.quote() was run on the extraction, we need to run
+            # urllib.parse.unquote() on the load.
+            unquote_external_ids=self._state.quoted_source_identifiers,
         )
+
         result = loader.load_into_cdf(client)
         self._state.instances.outcome.append(result)
         print("You can inspect the details with the .inspect.outcome.instances(...) method.")

cognite/neat/_session/_wizard.py

@@ -26,7 +26,7 @@ _T_Option = TypeVar("_T_Option")
 
 
 def _selection(message: str, options: Sequence[_T_Option]) -> _T_Option:
-    option_text = "\n  ".join([f"{i+1}) {option}" for i, option in enumerate(options)])
+    option_text = "\n  ".join([f"{i + 1}) {option}" for i, option in enumerate(options)])
     selected_index = (
         IntPrompt().ask(f"{message}\n  {option_text}\n", choices=list(map(str, range(1, len(options) + 1)))) - 1
     )

cognite/neat/_session/exceptions.py

@@ -3,6 +3,8 @@ from collections.abc import Callable
 from typing import Any
 
 from cognite.neat._issues.errors import CDFMissingClientError, NeatImportError
+from cognite.neat._issues.errors._external import OxigraphStorageLockedError
+from cognite.neat._issues.errors._general import NeatValueError
 
 from ._collector import _COLLECTOR
 
@@ -33,7 +35,12 @@ def _session_method_wrapper(func: Callable, cls_name: str):
         except NeatSessionError as e:
             action = _get_action()
             print(f"{_PREFIX} Cannot {action}: {e}")
-        except (CDFMissingClientError, NeatImportError) as e:
+        except (
+            CDFMissingClientError,
+            NeatImportError,
+            NeatValueError,
+            OxigraphStorageLockedError,
+        ) as e:
             print(f"{_PREFIX} {escape(e.as_message())}")
         except ModuleNotFoundError as e:
             if e.name == "neatengine":