cognite-neat 0.112.1__tar.gz → 0.113.1__tar.gz

{cognite_neat-0.112.1 → cognite_neat-0.113.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cognite-neat
-Version: 0.112.1
+Version: 0.113.1
 Summary: Knowledge graph transformation
 License: Apache-2.0
 Author: Nikola Vasiljevic

{cognite_neat-0.112.1 → cognite_neat-0.113.1}/cognite/neat/_session/_base.py

@@ -202,6 +202,7 @@ class NeatSession:
             neat.infer()
             ```
         """
+        self._state._raise_exception_if_condition_not_met("Data model inference", instances_required=True)
         return self._infer_subclasses(model_id)
 
     def _previous_inference(

{cognite_neat-0.112.1 → cognite_neat-0.113.1}/cognite/neat/_session/_read.py

@@ -87,12 +87,6 @@ class CDFReadAPI(BaseReadAPI):
         super().__init__(state, verbose)
         self.classic = CDFClassicAPI(state, verbose)
 
-    @property
-    def _get_client(self) -> NeatClient:
-        if self._state.client is None:
-            raise NeatValueError("No client provided. Please provide a client to read a data model.")
-        return self._state.client
-
     def data_model(self, data_model_id: DataModelIdentifier) -> IssueList:
         """Reads a Data Model from CDF to the knowledge graph.
 
@@ -111,7 +105,13 @@ class CDFReadAPI(BaseReadAPI):
         if not data_model_id.version:
             raise NeatSessionError("Data model version is required to read a data model.")
 
-        importer = importers.DMSImporter.from_data_model_id(self._get_client, data_model_id)
+        self._state._raise_exception_if_condition_not_met(
+            "Read data model from CDF",
+            empty_rules_store_required=True,
+            client_required=True,
+        )
+
+        importer = importers.DMSImporter.from_data_model_id(cast(NeatClient, self._state.client), data_model_id)
         return self._state.rule_import(importer)
 
     def graph(
@@ -132,6 +132,12 @@ class CDFReadAPI(BaseReadAPI):
             IssueList: A list of issues that occurred during the extraction.
 
         """
+        self._state._raise_exception_if_condition_not_met(
+            "Read DMS Graph",
+            empty_rules_store_required=True,
+            empty_instances_store_required=True,
+            client_required=True,
+        )
         return self._graph(data_model_id, instance_space, skip_cognite_views, unpack_json=False)
 
     def _graph(
@@ -145,7 +151,7 @@ class CDFReadAPI(BaseReadAPI):
         extractor = extractors.DMSGraphExtractor.from_data_model_id(
             # We are skipping the Cognite Views
             data_model_id,
-            self._get_client,
+            cast(NeatClient, self._state.client),
             instance_space=instance_space,
             skip_cognite_views=skip_cognite_views,
             unpack_json=unpack_json,
@@ -181,8 +187,13 @@ class CDFReadAPI(BaseReadAPI):
             ```
 
         """
+        self._state._raise_exception_if_condition_not_met(
+            "Read RAW",
+            client_required=True,
+        )
+
         extractor = extractors.RAWExtractor(
-            self._get_client,
+            cast(NeatClient, self._state.client),
             db_name=db_name,
             table_name=table_name,
             table_type=type,
@@ -200,12 +211,6 @@ class CDFClassicAPI(BaseReadAPI):
 
     """
 
-    @property
-    def _get_client(self) -> NeatClient:
-        if self._state.client is None:
-            raise ValueError("No client provided. Please provide a client to read a data model.")
-        return self._state.client
-
     def graph(
         self,
         root_asset_external_id: str,
@@ -257,6 +262,13 @@ class CDFClassicAPI(BaseReadAPI):
             neat.read.cdf.graph("root_asset_external_id")
             ```
         """
+        self._state._raise_exception_if_condition_not_met(
+            "Read classic graph",
+            empty_rules_store_required=True,
+            empty_instances_store_required=True,
+            client_required=True,
+        )
+
         return self._graph(
             root_asset_external_id, limit_per_type, identifier, reference_timeseries=False, reference_files=False
         )
@@ -273,7 +285,7 @@ class CDFClassicAPI(BaseReadAPI):
     ) -> IssueList:
         namespace = CLASSIC_CDF_NAMESPACE
         extractor = extractors.ClassicGraphExtractor(
-            self._get_client,
+            cast(NeatClient, self._state.client),
             root_asset_external_id=root_asset_external_id,
             limit_per_type=limit_per_type,
             namespace=namespace,
@@ -298,6 +310,8 @@ class CDFClassicAPI(BaseReadAPI):
         self._state.instances.store.transform(
             LiteralToEntity(None, namespace["source"], "ClassicSourceSystem", "name"),
         )
+        # 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(
             ClassicPrepareCore(namespace, reference_timeseries, reference_files)
@@ -467,6 +481,12 @@ class XMLReadAPI(BaseReadAPI):
         warnings.filterwarnings("default")
         AlphaFlags.dexpi_read.warn()
 
+        self._state._raise_exception_if_condition_not_met(
+            "Read DEXPI file",
+            empty_rules_store_required=True,
+            empty_instances_store_required=True,
+        )
+
         path = NeatReader.create(io).materialize_path()
         engine = import_engine()
         engine.set.format = "dexpi"
@@ -521,6 +541,12 @@ class XMLReadAPI(BaseReadAPI):
         warnings.filterwarnings("default")
         AlphaFlags.aml_read.warn()
 
+        self._state._raise_exception_if_condition_not_met(
+            "Read AML file",
+            empty_rules_store_required=True,
+            empty_instances_store_required=True,
+        )
+
         path = NeatReader.create(io).materialize_path()
         engine = import_engine()
         engine.set.format = "aml"
@@ -575,6 +601,11 @@ class RDFReadAPI(BaseReadAPI):
         warnings.filterwarnings("default")
         AlphaFlags.ontology_read.warn()
 
+        self._state._raise_exception_if_condition_not_met(
+            "Read Ontology file",
+            empty_rules_store_required=True,
+        )
+
         reader = NeatReader.create(io)
         importer = importers.OWLImporter.from_file(reader.materialize_path(), source_name=f"file {reader!s}")
         return self._state.rule_import(importer)
@@ -593,6 +624,11 @@ class RDFReadAPI(BaseReadAPI):
         warnings.filterwarnings("default")
         AlphaFlags.imf_read.warn()
 
+        self._state._raise_exception_if_condition_not_met(
+            "Read IMF file",
+            empty_rules_store_required=True,
+        )
+
         reader = NeatReader.create(io)
         importer = importers.IMFImporter.from_file(reader.materialize_path(), source_name=f"file {reader!s}")
         return self._state.rule_import(importer)
@@ -646,17 +682,35 @@ class Examples:
 
     def nordic44(self) -> IssueList:
         """Reads the Nordic 44 knowledge graph into the NeatSession graph store."""
+
+        self._state._raise_exception_if_condition_not_met(
+            "Read Nordic44 graph example",
+            empty_instances_store_required=True,
+            empty_rules_store_required=True,
+        )
+
         self._state.instances.store.write(extractors.RdfFileExtractor(instances_examples.nordic44_knowledge_graph))
         return IssueList()
 
     def pump_example(self) -> IssueList:
         """Reads the Hello World pump example into the NeatSession."""
+
+        self._state._raise_exception_if_condition_not_met(
+            "Read Pump Data Model example",
+            empty_rules_store_required=True,
+        )
+
         importer: importers.ExcelImporter = importers.ExcelImporter(catalog.hello_world_pump)
         return self._state.rule_import(importer)
 
     def core_data_model(self) -> IssueList:
         """Reads the core data model example into the NeatSession."""
 
+        self._state._raise_exception_if_condition_not_met(
+            "Read Core Data Model example",
+            empty_rules_store_required=True,
+        )
+
         cdm_v1 = DataModelId.load(("cdf_cdm", "CogniteCore", "v1"))
         importer: importers.DMSImporter = importers.DMSImporter.from_data_model_id(self._get_client, cdm_v1)
         return self._state.rule_import(importer)

{cognite_neat-0.112.1 → cognite_neat-0.113.1}/cognite/neat/_session/_state.py

@@ -65,6 +65,34 @@ class SessionState:
         issues.extend(extract_issues)
         return issues
 
+    def _raise_exception_if_condition_not_met(
+        self,
+        activity: str,
+        empty_rules_store_required: bool = False,
+        empty_instances_store_required: bool = False,
+        instances_required: bool = False,
+        client_required: bool = False,
+    ) -> None:
+        """Set conditions for raising an error in the session that are used by various methods in the session."""
+        condition = set()
+        suggestion = set()
+
+        if client_required and not self.client:
+            condition.add(f"{activity} expects a client in NEAT session")
+            suggestion.add("Please provide a client")
+        if empty_rules_store_required and not self.rule_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:
+            condition.add(f"{activity} expects no instances in NEAT session")
+            suggestion.add("Start new session")
+        if instances_required and self.instances.empty:
+            condition.add(f"{activity} expects instances in NEAT session")
+            suggestion.add("Read in instances to neat session")
+
+        if condition:
+            raise NeatSessionError(". ".join(condition) + ". " + ". ".join(suggestion) + ". And try again.")
+
 
 class InstancesState:
     def __init__(

{cognite_neat-0.112.1 → cognite_neat-0.113.1}/cognite/neat/_session/_to.py

@@ -2,12 +2,13 @@ import warnings
 import zipfile
 from collections.abc import Collection
 from pathlib import Path
-from typing import Any, Literal, overload
+from typing import Any, Literal, cast, overload
 
 from cognite.client import data_modeling as dm
 from cognite.client.data_classes.data_modeling import DataModelIdentifier
 
 from cognite.neat._alpha import AlphaFlags
+from cognite.neat._client._api_client import NeatClient
 from cognite.neat._constants import COGNITE_MODELS
 from cognite.neat._graph import loaders
 from cognite.neat._issues import IssueList, NeatIssue, catch_issues
@@ -305,9 +306,12 @@ class CDFToAPI:
         space_from_property: str | None = None,
         use_source_space: bool = False,
     ) -> UploadResultList:
-        if not self._state.client:
-            raise NeatSessionError("No CDF client provided!")
-        client = self._state.client
+        self._state._raise_exception_if_condition_not_met(
+            "Export DMS instances to CDF",
+            client_required=True,
+        )
+
+        client = cast(NeatClient, self._state.client)
         dms_rules = self._state.rule_store.last_verified_dms_rules
         instance_space = instance_space or f"{dms_rules.metadata.space}_instances"
 
@@ -366,12 +370,14 @@ class CDFToAPI:
 
         """
 
-        exporter = exporters.DMSExporter(existing=existing, export_components=components, drop_data=drop_data)
+        self._state._raise_exception_if_condition_not_met(
+            "Export DMS data model to CDF",
+            client_required=True,
+        )
 
-        if not self._state.client:
-            raise NeatSessionError("No client provided!")
+        exporter = exporters.DMSExporter(existing=existing, export_components=components, drop_data=drop_data)
 
-        result = self._state.rule_store.export_to_cdf(exporter, self._state.client, dry_run)
+        result = self._state.rule_store.export_to_cdf(exporter, cast(NeatClient, self._state.client), dry_run)
         print("You can inspect the details with the .inspect.outcome.data_model(...) method.")
         return result
 

cognite_neat-0.113.1/cognite/neat/_version.py

@@ -0,0 +1,2 @@
+__version__ = "0.113.1"
+__engine__ = "^2.0.4"

{cognite_neat-0.112.1 → cognite_neat-0.113.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cognite-neat"
-version = "0.112.1"
+version = "0.113.1"
 readme = "README.md"
 description = "Knowledge graph transformation"
 authors = [

cognite_neat-0.112.1/cognite/neat/_version.py

@@ -1,2 +0,0 @@
-__version__ = "0.112.1"
-__engine__ = "^2.0.4"