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

cognite/neat/_version.py

@@ -1,2 +1,2 @@
-__version__ = "0.122.1"
+__version__ = "0.122.2"
 __engine__ = "^2.0.4"

cognite/neat/core/_data_model/importers/_dms2data_model.py

@@ -269,14 +269,14 @@ class DMSImporter(BaseImporter[UnverifiedPhysicalDataModel]):
 
         model = self.schema.data_model
 
-        user_data_model = self._create_rule_components(model, self.schema, self.metadata)
+        user_data_model = self._create_data_model_components(model, self.schema, self.metadata)
 
         self.issue_list.trigger_warnings()
         if self.issue_list.has_errors:
             raise MultiValueError(self.issue_list.errors)
         return ImportedDataModel(user_data_model, {})
 
-    def _create_rule_components(
+    def _create_data_model_components(
         self,
         data_model: dm.DataModelApply,
         schema: DMSSchema,

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

@@ -2346,7 +2346,7 @@ class AddCogniteProperties(
     ) -> ImportedDataModel[UnverifiedConceptualDataModel]:
         input_ = data_model.unverified_data_model
         if input_ is None:
-            raise NeatValueError("Rule read failed. Cannot add cognite properties to None data_model.")
+            raise NeatValueError("Data model read failed. Cannot add cognite properties to None data_model.")
 
         default_space = input_.metadata.space
         default_version = input_.metadata.version

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

@@ -29,7 +29,7 @@ from ._base import VerifiedDataModelTransformer
 
 
 class MapOntoTransformers(VerifiedDataModelTransformer[PhysicalDataModel, PhysicalDataModel], ABC):
-    """Base class for transformers that map one rule onto another."""
+    """Base class for transformers that map one data model onto another."""
 
     ...
 

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

@@ -54,7 +54,7 @@ class VerificationTransformer(DataModelTransformer[T_ImportedUnverifiedDataModel
                 elif issubclass(validation_cls, ConceptualValidation):
                     validation_issues = ConceptualValidation(verified_data_model, data_model.context).validate()  # type: ignore[arg-type]
                 else:
-                    raise NeatValueError("Unsupported rule type")
+                    raise NeatValueError("Unsupported data model type")
                 issues.extend(validation_issues)
 
         # Raise issues which is expected to be handled outside of this method

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

@@ -1,7 +1,8 @@
 from ._base import BaseLoader, CDFLoader
 from ._rdf2dms import DMSLoader
+from ._rdf_to_instance_space import InstanceSpaceLoader
 
-__all__ = ["BaseLoader", "CDFLoader", "DMSLoader"]
+__all__ = ["BaseLoader", "CDFLoader", "DMSLoader", "InstanceSpaceLoader"]
 
 
 def _repr_html_() -> str:

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

@@ -3,12 +3,11 @@ from collections.abc import Hashable, Iterable
 from pathlib import Path
 from typing import ClassVar, Generic, TypeVar
 
-from cognite.client import CogniteClient
 from cognite.client.data_classes.capabilities import Capability
 
+from cognite.neat.core._client import NeatClient
 from cognite.neat.core._issues import IssueList, NeatIssue
 from cognite.neat.core._issues.errors import AuthorizationError
-from cognite.neat.core._store import NeatInstanceStore
 from cognite.neat.core._utils.auxiliary import class_html_doc
 from cognite.neat.core._utils.upload import UploadResult, UploadResultList
 
@@ -29,9 +28,6 @@ class BaseLoader(ABC, Generic[T_Output]):
     _new_line = "\n"
     _encoding = "utf-8"
 
-    def __init__(self, instance_store: NeatInstanceStore):
-        self.instance_store = instance_store
-
     @abstractmethod
     def write_to_file(self, filepath: Path) -> None:
         raise NotImplementedError
@@ -59,9 +55,7 @@ class BaseLoader(ABC, Generic[T_Output]):
 class CDFLoader(BaseLoader[T_Output]):
     _UPLOAD_BATCH_SIZE: ClassVar[int] = 1000
 
-    def load_into_cdf(
-        self, client: CogniteClient, dry_run: bool = False, check_client: bool = True
-    ) -> UploadResultList:
+    def load_into_cdf(self, client: NeatClient, dry_run: bool = False, check_client: bool = True) -> UploadResultList:
         upload_result_by_name: dict[str, UploadResult] = {}
         for upload_result in self.load_into_cdf_iterable(client, dry_run, check_client):
             if last_result := upload_result_by_name.get(upload_result.name):
@@ -72,7 +66,7 @@ class CDFLoader(BaseLoader[T_Output]):
         return UploadResultList(upload_result_by_name.values())
 
     def load_into_cdf_iterable(
-        self, client: CogniteClient, dry_run: bool = False, check_client: bool = True
+        self, client: NeatClient, dry_run: bool = False, check_client: bool = True
     ) -> Iterable[UploadResult]:
         if check_client:
             missing_capabilities = client.iam.verify_capabilities(self._get_required_capabilities())
@@ -113,7 +107,7 @@ class CDFLoader(BaseLoader[T_Output]):
     @abstractmethod
     def _upload_to_cdf(
         self,
-        client: CogniteClient,
+        client: NeatClient,
         items: list[T_Output],
         dry_run: bool,
         read_issues: IssueList,

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

@@ -6,7 +6,7 @@ from collections import defaultdict
 from collections.abc import Iterable, Sequence
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Literal, cast, get_args, overload
+from typing import Any, Literal, cast, get_args
 
 import yaml
 from cognite.client import CogniteClient
@@ -39,13 +39,11 @@ from cognite.neat.core._data_model.models.data_types import (
 )
 from cognite.neat.core._issues import IssueList, NeatError, NeatIssue, catch_issues
 from cognite.neat.core._issues.errors import (
-    AuthorizationError,
     ResourceCreationError,
     ResourceDuplicatedError,
     ResourceNotFoundError,
 )
 from cognite.neat.core._issues.warnings import (
-    NeatValueWarning,
     PropertyDirectRelationLimitWarning,
     PropertyMultipleValueWarning,
     PropertyTypeNotSupportedWarning,
@@ -58,11 +56,8 @@ from cognite.neat.core._utils.collection_ import (
     iterate_progress_bar_if_above_config_threshold,
 )
 from cognite.neat.core._utils.rdf_ import (
-    namespace_as_space,
     remove_namespace_from_uri,
-    split_uri,
 )
-from cognite.neat.core._utils.text import NamingStandardization
 from cognite.neat.core._utils.upload import UploadResult
 
 from ._base import _END_OF_CLASS, _START_OF_CLASS, CDFLoader
@@ -104,14 +99,10 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         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
             creates instances in accordance with required constraints. Defaults to None.
         unquote_external_ids (bool): If True, the loader will unquote external ids before creating the instances.
-        neat_prefix_by_predicate_uri (dict[URIRef, str] | None): A dictionary that maps a predicate URIRef to a
-            prefix that Neat added to the object upon extraction. This is used to remove the prefix from the
-            object before creating the instance.
     """
 
     def __init__(
@@ -119,24 +110,17 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         physical_data_model: PhysicalDataModel,
         conceptual_data_model: ConceptualDataModel,
         instance_store: NeatInstanceStore,
-        instance_space: str,
-        space_property: str | None = None,
-        use_source_space: bool = False,
+        space_by_instance_uri: dict[URIRef, str],
         client: NeatClient | None = None,
         create_issues: Sequence[NeatIssue] | None = None,
         unquote_external_ids: bool = False,
-        neat_prefix_by_predicate_uri: dict[URIRef, str] | None = None,
         neat_prefix_by_type_uri: dict[URIRef, str] | None = None,
     ):
-        super().__init__(instance_store)
+        self.instance_store = 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
-        self._space_property = space_property
-        self._use_source_space = use_source_space
-        self._space_by_instance_uri: dict[URIRef, str] = defaultdict(lambda: instance_space)
+        self._space_by_instance_uri = space_by_instance_uri
         self._external_id_by_uri: dict[URIRef, str] = {}
         self._issues = IssueList(create_issues or [])
         self._client = client
@@ -172,16 +156,6 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             return
         view_iterations, issues = self._create_view_iterations()
         yield from issues
-        if self._space_property:
-            yield from self._lookup_space_by_uri(view_iterations, stop_on_exception)
-
-            if self._client:
-                space_creation = self._create_instance_space_if_not_exists()
-                yield from space_creation.warnings
-                if space_creation.has_errors and stop_on_exception:
-                    raise space_creation.as_exception()
-                yield from space_creation.errors
-
         if self.neat_prefix_by_type_uri:
             self._lookup_identifier_by_uri()
 
@@ -280,46 +254,6 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
                 view_iterations[view_id] = _ViewIterator(view_id, count, query)
         return view_iterations
 
-    def _lookup_space_by_uri(self, view_iterations: list[_ViewIterator], stop_on_exception: bool = False) -> IssueList:
-        issues = IssueList()
-        if self._space_property is None:
-            return issues
-        total = sum(it.instance_count for it in view_iterations)
-        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(
-                self._space_property,
-                "property",
-                more=f"Could not find the {self._space_property} in the graph.",
-            )
-            if stop_on_exception:
-                raise error
-            issues.append(error)
-            return issues
-
-        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..."
-        )
-        neat_prefix = self.neat_prefix_by_predicate_uri.get(space_property_uri)
-        warned_spaces: set[str] = set()
-        for instance, space in instance_iterable:
-            if neat_prefix:
-                space = space.removeprefix(neat_prefix)
-
-            clean_space = NamingStandardization.standardize_space_str(space)
-            if clean_space != space and space not in warned_spaces:
-                issues.append(
-                    NeatValueWarning(
-                        f"Invalid space in property {self._space_property}: {space}. Fixed to {clean_space}"
-                    )
-                )
-                warned_spaces.add(space)
-
-            self._space_by_instance_uri[instance] = clean_space
-        return issues
-
     def _lookup_identifier_by_uri(self) -> None:
         if not self.neat_prefix_by_type_uri:
             return
@@ -343,20 +277,6 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             if len(uris) == 1:
                 self._external_id_by_uri[uris[0]] = identifier
 
-    def _create_instance_space_if_not_exists(self) -> IssueList:
-        issues = IssueList()
-        if not self._client:
-            return issues
-
-        instance_spaces = set(self._space_by_instance_uri.values()) - {self._instance_space}
-        existing_spaces = {space.space for space in self._client.data_modeling.spaces.retrieve(list(instance_spaces))}
-        if missing_spaces := (instance_spaces - existing_spaces):
-            try:
-                self._client.data_modeling.spaces.apply([dm.SpaceApply(space=space) for space in missing_spaces])
-            except CogniteAPIError as e:
-                issues.append(AuthorizationError(f"Creating {len(missing_spaces)} instance spaces.", str(e)))
-        return issues
-
     def _create_projection(self, view: dm.View) -> tuple[_Projection, IssueList]:
         issues = IssueList()
         field_definitions: dict[str, tuple[type, Any]] = {}
@@ -473,12 +393,10 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
                         )
                         value = value[:limit]
 
-                    ids = (self._create_instance_id(v, "node", stop_on_exception=True) for v in value)
+                    ids = (self._create_instance_id(v) for v in value)
                     return [id_.dump(camel_case=True, include_instance_type=False) for id_ in ids]
                 elif value:
-                    return self._create_instance_id(value[0], "node", stop_on_exception=True).dump(
-                        camel_case=True, include_instance_type=False
-                    )
+                    return self._create_instance_id(value[0]).dump(camel_case=True, include_instance_type=False)
                 return {}
 
             validators["parse_direct_relation"] = field_validator(*direct_relation_by_property.keys(), mode="before")(  # type: ignore[assignment]
@@ -518,7 +436,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         projection: _Projection,
         stop_on_exception: Literal[True, False] = False,
     ) -> Iterable[dm.InstanceApply | NeatIssue]:
-        instance_id = self._create_instance_id(instance_uri, "node", stop_on_exception)
+        instance_id = self._create_instance_id(instance_uri)
         if not isinstance(instance_id, InstanceId):
             yield instance_id
             return
@@ -567,8 +485,8 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             return
 
         if start_node and end_node:
-            start = self._create_instance_id(start_node, "edge", stop_on_exception)
-            end = self._create_instance_id(end_node, "edge", stop_on_exception)
+            start = self._create_instance_id(start_node)
+            end = self._create_instance_id(end_node)
             if isinstance(start, NeatError):
                 yield start
             if isinstance(end, NeatError):
@@ -594,7 +512,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
                 ),
                 sources=sources,
             )
-        yield from self._create_edges_without_properties(space, external_id, properties, projection, stop_on_exception)
+        yield from self._create_edges_without_properties(space, external_id, properties, projection)
 
     def _create_edges_without_properties(
         self,
@@ -602,7 +520,6 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         identifier: str,
         properties: dict[str | InstanceType, list[str] | list[URIRef]],
         projection: _Projection,
-        stop_on_exception: Literal[True, False],
     ) -> Iterable[dm.EdgeApply | NeatIssue]:
         for predicate, values in properties.items():
             if predicate in projection.edge_by_type:
@@ -620,10 +537,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
                 yield error
                 continue
             for target in values:
-                target_id = self._create_instance_id(target, "edge", stop_on_exception)  # type: ignore[call-overload]
-                if not isinstance(target_id, InstanceId):
-                    yield target_id
-                    continue
+                target_id = self._create_instance_id(cast(URIRef, target))
                 if isinstance(target, URIRef):
                     target = remove_namespace_from_uri(target)
                 external_id = f"{identifier}.{prop_id}.{target}"
@@ -656,43 +570,16 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             return start_node, end_node  # type: ignore[return-value]
         return None, None
 
-    @overload
-    def _create_instance_id(
-        self, uri: URIRef, instance_type: str, stop_on_exception: Literal[False] = False
-    ) -> InstanceId | NeatError: ...
-
-    @overload
-    def _create_instance_id(
-        self, uri: URIRef, instance_type: str, stop_on_exception: Literal[True] = True
-    ) -> InstanceId: ...
-
-    def _create_instance_id(
-        self, uri: URIRef, instance_type: str, stop_on_exception: bool = False
-    ) -> InstanceId | NeatError:
-        space: str | None = None
-        external_id: str | None = None
-        error: NeatError | None = None
-        if self._use_source_space:
-            namespace, external_id = split_uri(uri)
-            space = namespace_as_space(namespace)
-            if space is None:
-                error = ResourceCreationError(uri, instance_type, f"Could not find space for {uri!s}.")
+    def _create_instance_id(self, uri: URIRef) -> InstanceId:
+        space = self._space_by_instance_uri[uri]
+        if uri in self._external_id_by_uri:
+            external_id = self._external_id_by_uri[uri]
         else:
-            space = self._space_by_instance_uri[uri]
-            if uri in self._external_id_by_uri:
-                external_id = self._external_id_by_uri[uri]
-            else:
-                external_id = remove_namespace_from_uri(uri)
+            external_id = remove_namespace_from_uri(uri)
 
         if external_id and self._unquote_external_ids:
             external_id = urllib.parse.unquote(external_id)
-        if space and external_id:
-            return InstanceId(space, external_id)
-        if error is None:
-            raise ValueError(f"Bug in neat. Failed to create instance ID and determine error for {uri!r}")
-        if stop_on_exception:
-            raise error
-        return error
+        return InstanceId(space, external_id)
 
     def _get_required_capabilities(self) -> list[Capability]:
         return [
@@ -702,7 +589,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
                     DataModelInstancesAcl.Action.Write_Properties,
                     DataModelInstancesAcl.Action.Read,
                 ],
-                scope=DataModelInstancesAcl.Scope.SpaceID([self._instance_space]),
+                scope=DataModelInstancesAcl.Scope.SpaceID(sorted(set(self._space_by_instance_uri.values()))),
             )
         ]
 

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

@@ -0,0 +1,249 @@
+import itertools
+import json
+from collections import defaultdict
+from collections.abc import Iterable
+from pathlib import Path
+from typing import cast
+
+import yaml
+from cognite.client import data_modeling as dm
+from cognite.client.data_classes.capabilities import Capability, DataModelsAcl
+from rdflib import URIRef
+
+from cognite.neat.core._client import NeatClient
+from cognite.neat.core._client._api.data_modeling_loaders import MultiCogniteAPIError
+from cognite.neat.core._constants import COGNITE_SPACES
+from cognite.neat.core._issues import IssueList, NeatIssue
+from cognite.neat.core._issues.errors import ResourceCreationError, ResourceNotFoundError
+from cognite.neat.core._issues.warnings import NeatValueWarning
+from cognite.neat.core._store import NeatInstanceStore
+from cognite.neat.core._utils.collection_ import iterate_progress_bar_if_above_config_threshold
+from cognite.neat.core._utils.rdf_ import namespace_as_space, split_uri
+from cognite.neat.core._utils.text import NamingStandardization
+from cognite.neat.core._utils.upload import UploadResult
+
+from ._base import _END_OF_CLASS, _START_OF_CLASS, CDFLoader
+
+
+class InstanceSpaceLoader(CDFLoader[dm.SpaceApply]):
+    """Loads Instance Space into Cognite Data Fusion (CDF).
+
+    There are three ways to determine the space for each instance:
+    1. If `instance_space` is provided, all instances will be assigned to that space, i.e., the space
+        is constant for all instances.
+    (If not it is set based on the triples (subject, predicate, object) in the graph store.)
+    2. If `space_property` is provided, this is the predicate and the space is set to the object. The `instance_space`
+       is used as a fallback if the object is not a valid space.
+    3. If `use_source_space` is set to True, the instances are assumed to be extracted from CDF and the space is part
+        of the subject.
+
+    This class exposes the `space_by_instance_uri` property used by the DMSLoader to lookup space for each instance URI.
+
+    Args:
+        graph_store (NeatInstanceStore): The graph store to load the data from.
+        instance_space (str): The instance space to load the data into.
+        space_property (str): The property to use to determine the space for each instance.
+        use_source_space (bool): If True, use the source space of the instances when extracted from CDF.
+        neat_prefix_by_predicate_uri (dict[URIRef, str] | None): A dictionary that maps a predicate URIRef to a
+            prefix that Neat added to the object upon extraction. This is used to remove the prefix from the
+            object before creating the instance.
+    """
+
+    def __init__(
+        self,
+        graph_store: NeatInstanceStore | None = None,
+        instance_space: str | None = None,
+        space_property: str | None = None,
+        use_source_space: bool = False,
+        neat_prefix_by_predicate_uri: dict[URIRef, str] | None = None,
+    ) -> None:
+        self.graph_store = graph_store
+        self.instance_space = instance_space
+        self.space_property = space_property
+        self.use_source_space = use_source_space
+        self.neat_prefix_by_predicate_uri = neat_prefix_by_predicate_uri or {}
+
+        self._lookup_issues = IssueList()
+
+        self._has_looked_up = False
+        # This is a dictionary mapping instance URIs to their respective spaces
+        # This is exposed through the property space_by_instance_uri. If the instance_space or space_property is
+        # set (1. and 2.) this is changed to a defaultdict with the instance_space as the default value.
+        self._space_by_instance_uri: dict[URIRef, str] = {}
+
+    @property
+    def space_by_instance_uri(self) -> dict[URIRef, str]:
+        """Returns a dictionary mapping instance URIs to their respective spaces."""
+        if not self._has_looked_up:
+            self._lookup_spaces()
+            self._has_looked_up = True
+        return self._space_by_instance_uri
+
+    def _get_required_capabilities(self) -> list[Capability]:
+        return [
+            DataModelsAcl(
+                actions=[
+                    DataModelsAcl.Action.Write,
+                    DataModelsAcl.Action.Read,
+                ],
+                scope=DataModelsAcl.Scope.All(),
+            )
+        ]
+
+    def _upload_to_cdf(
+        self,
+        client: NeatClient,
+        spaces: list[dm.SpaceApply],
+        dry_run: bool,
+        read_issues: IssueList,
+        class_name: str | None = None,
+    ) -> Iterable[UploadResult]:
+        cdf_spaces = client.data_modeling.spaces.retrieve([space.space for space in spaces])
+        cdf_space_by_id = {item.space: item for item in cdf_spaces}
+
+        to_create = dm.SpaceApplyList([])
+        to_update = dm.SpaceApplyList([])
+        unchanged = dm.SpaceApplyList([])
+
+        for local_space in spaces:
+            cdf_space = cdf_space_by_id.get(local_space.space)
+            if cdf_space is None:
+                to_create.append(local_space)
+            elif cdf_space != local_space.as_write():
+                to_update.append(local_space)
+            else:
+                unchanged.append(local_space)
+        loader = client.loaders.spaces
+        results: UploadResult[str] = UploadResult("instance spaces")
+        results.unchanged.update(unchanged.as_ids())
+        if dry_run:
+            results.created.update(to_create.as_ids())
+            results.changed.update(to_update.as_ids())
+            yield results
+        if to_create:
+            try:
+                client.loaders.spaces.create(to_create)
+            except MultiCogniteAPIError as e:
+                results.failed_created.update(to_create.as_ids())
+                for error in e.errors:
+                    results.error_messages.append(f"Failed to create {loader.resource_name}: {error!s}")
+            else:
+                results.created.update(to_create.as_ids())
+
+        if to_update:
+            try:
+                client.loaders.spaces.update(to_update)
+            except MultiCogniteAPIError as e:
+                results.failed_changed.update(to_update.as_ids())
+                for error in e.errors:
+                    results.error_messages.append(f"Failed to update {loader.resource_name}: {error!s}")
+            else:
+                results.changed.update(to_update.as_ids())
+
+        yield results
+
+    def write_to_file(self, filepath: Path) -> None:
+        """Dumps the instance spaces to file."""
+        if filepath.suffix not in [".json", ".yaml", ".yml"]:
+            raise ValueError(f"File format {filepath.suffix} is not supported")
+        dumped: dict[str, list] = {"spaces": [], "issues": []}
+        for item in self.load(stop_on_exception=False):
+            key = {
+                dm.SpaceApply: "spaces",
+                NeatIssue: "issues",
+            }.get(type(item))
+            if key is None:
+                # This should never happen, and is a bug in neat
+                raise ValueError(f"Item {item} is not supported. This is a bug in neat please report it.")
+            dumped[key].append(item.dump())
+        with filepath.open("w", encoding=self._encoding, newline=self._new_line) as f:
+            if filepath.suffix == ".json":
+                json.dump(dumped, f, indent=2)
+            else:
+                yaml.safe_dump(dumped, f, sort_keys=False)
+
+    def _load(
+        self, stop_on_exception: bool = False
+    ) -> Iterable[dm.SpaceApply | NeatIssue | type[_END_OF_CLASS] | _START_OF_CLASS]:
+        self._lookup_spaces()
+        if self._lookup_issues.has_errors and stop_on_exception:
+            raise self._lookup_issues.as_errors()
+        yield from self._lookup_issues
+        seen: set[str] = set()
+        for space_str in set(self.space_by_instance_uri.values()):
+            if space_str in seen or space_str in COGNITE_SPACES:
+                continue
+            yield dm.SpaceApply(space=space_str)
+            seen.add(space_str)
+
+    def _lookup_spaces(self) -> None:
+        # Case 1: Same instance space for all instances:
+        if isinstance(self.instance_space, str) and self.space_property is None and self.use_source_space is False:
+            self._space_by_instance_uri = defaultdict(lambda: cast(str, self.instance_space))
+            # Adding a dummy entry to ensure that the instance space is included
+            self._space_by_instance_uri[URIRef(self.instance_space)] = self.instance_space
+            return
+        if self.graph_store is None:
+            raise ValueError("Graph store must be provided to lookup spaces")
+        # Case 3: Use the source space, i.e., the space of the instances when extracted from CDF
+        if self.use_source_space and self.instance_space is None and self.space_property is None:
+            self._lookup_space_via_instance_uris(self.graph_store)
+        # Case 2: Use a property on each instance to determine the space.
+        elif self.space_property is not None and self.use_source_space is False:
+            if self.instance_space is None:
+                raise ValueError(
+                    "Missing fallback instance space. This is required when "
+                    f"using space_property='{self.space_property}'"
+                )
+            self._space_by_instance_uri = defaultdict(lambda: cast(str, self.instance_space))
+            self._lookup_space_via_property(self.graph_store, self.space_property)
+        else:
+            raise ValueError("Either 'instance_space', 'space_property', or 'use_source_space' must be provided.")
+
+    def _lookup_space_via_instance_uris(self, graph_store: NeatInstanceStore) -> None:
+        instance_iterable = itertools.chain(
+            (res[0] for res in graph_store.queries.select.list_instances_ids()),
+            graph_store.queries.select.list_instance_object_ids(),
+        )
+
+        for instance_uri in instance_iterable:
+            namespace, external_id = split_uri(instance_uri)
+            space = namespace_as_space(namespace)
+            if space is None:
+                error = ResourceCreationError(instance_uri, "instance", "This instance was not extracted from CDF.")
+                self._lookup_issues.append(error)
+            else:
+                self._space_by_instance_uri[instance_uri] = space
+
+    def _lookup_space_via_property(self, graph_store: NeatInstanceStore, space_property: str) -> None:
+        properties_by_uriref = graph_store.queries.select.properties()
+        space_property_uri = next((k for k, v in properties_by_uriref.items() if v == space_property), None)
+        if space_property_uri is None:
+            error: ResourceNotFoundError[str, str] = ResourceNotFoundError(
+                self.space_property,
+                "property",
+                more=f"Could not find the {space_property} in the graph.",
+            )
+            self._lookup_issues.append(error)
+            return
+
+        class_with_total_pair = graph_store.queries.select.summarize_instances()
+        total = sum([count for _, count in class_with_total_pair])
+        instance_iterable = graph_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..."
+        )
+        neat_prefix = self.neat_prefix_by_predicate_uri.get(space_property_uri)
+        warned_spaces: set[str] = set()
+        for instance, space in instance_iterable:
+            if neat_prefix:
+                space = space.removeprefix(neat_prefix)
+
+            clean_space = NamingStandardization.standardize_space_str(space)
+            if clean_space != space and space not in warned_spaces:
+                self._lookup_issues.append(
+                    NeatValueWarning(f"Invalid space in property {space_property}: {space}. Fixed to {clean_space}")
+                )
+                warned_spaces.add(space)
+
+            self._space_by_instance_uri[instance] = clean_space

cognite/neat/core/_instances/queries/_select.py

@@ -120,6 +120,18 @@ class SelectQueries(BaseQuery):
         # MyPy is not very happy with RDFLib, so just ignore the type hinting here
         return (tuple(res) if class_uri is None else res[0] for res in self.graph(named_graph).query(query))  # type: ignore[index, return-value, arg-type]
 
+    def list_instance_object_ids(self, limit: int = -1, named_graph: URIRef | None = None) -> Iterable[URIRef]:
+        query = (
+            "SELECT DISTINCT ?object WHERE { "
+            "?subject ?predicate ?object . FILTER(?predicate != rdf:type && isURI(?object))"
+            "}"
+        )
+        if limit != -1:
+            query += f" LIMIT {limit}"
+
+        # MyPy is not very happy with RDFLib, so just ignore the type hinting here
+        return cast(Iterable[URIRef], (res[0] for res in self.graph(named_graph).query(query)))  # type: ignore[index]
+
     def type_with_property(self, type_: URIRef, property_uri: URIRef, named_graph: URIRef | None = None) -> bool:
         """Check if a property exists in the graph store
 

cognite/neat/session/_base.py

@@ -174,7 +174,7 @@ class NeatSession:
         )
         converter = ConceptualToPhysical(reserved_properties=reserved_properties, client=self._state.client)
 
-        issues = self._state.rule_transform(converter)
+        issues = self._state.data_model_transform(converter)
 
         if self._verbose and not issues.has_errors:
             print("Conceptual data model converted to physical data model.")
@@ -222,7 +222,7 @@ class NeatSession:
             max_number_of_instance=max_number_of_instance,
             data_model_id=model_id,
         )
-        return self._state.rule_import(importer)
+        return self._state.data_model_import(importer)
 
     def _infer_subclasses(
         self,

cognite/neat/session/_drop.py

@@ -97,7 +97,7 @@ class DropDataModelAPI:
                     f"{len(missing_views)} view(s) not found in the data model.\nDid you mean {', '.join(suggestions)}?"
                 )
         before = len(last_dms.views)
-        issues = self._state.rule_transform(DropModelViews(view_external_id, group))
+        issues = self._state.data_model_transform(DropModelViews(view_external_id, group))
         after = len(self._state.data_model_store.last_verified_physical_data_model.views)
         print(f"Dropped {before - after} views.")
         return issues

cognite/neat/session/_fix.py

@@ -25,4 +25,4 @@ class DataModelFixAPI:
 
     def cdf_compliant_external_ids(self) -> IssueList:
         """Convert (information/logical) data model component external ids to CDF compliant entities."""
-        return self._state.rule_transform(ToCompliantEntities())
+        return self._state.data_model_transform(ToCompliantEntities())

cognite/neat/session/_mapping.py

@@ -68,4 +68,4 @@ class DataModelMappingAPI:
         )
         if use_parent_property_name:
             transformers.append(AsParentPropertyId(self._state.client))
-        return self._state.rule_transform(*transformers)
+        return self._state.data_model_transform(*transformers)

cognite/neat/session/_prepare.py

@@ -264,7 +264,7 @@ class DataModelPrepareAPI:
 
         """
 
-        return self._state.rule_transform(PrefixEntities(prefix))  # type: ignore[arg-type]
+        return self._state.data_model_transform(PrefixEntities(prefix))  # type: ignore[arg-type]
 
     def standardize_naming(self) -> IssueList:
         """Standardize the naming of all views/classes/properties in the data model.
@@ -274,7 +274,7 @@ class DataModelPrepareAPI:
         """
         warnings.filterwarnings("default")
         ExperimentalFlags.standardize_naming.warn()
-        return self._state.rule_transform(StandardizeNaming())
+        return self._state.data_model_transform(StandardizeNaming())
 
     def standardize_space_and_version(self) -> IssueList:
         """Standardize space and version in the data model.
@@ -283,4 +283,4 @@ class DataModelPrepareAPI:
         """
         warnings.filterwarnings("default")
         ExperimentalFlags.standardize_space_and_version.warn()
-        return self._state.rule_transform(StandardizeSpaceAndVersion())
+        return self._state.data_model_transform(StandardizeSpaceAndVersion())

cognite/neat/session/_read.py

@@ -118,7 +118,7 @@ class CDFReadAPI(BaseReadAPI):
         )
 
         importer = importers.DMSImporter.from_data_model_id(cast(NeatClient, self._state.client), data_model_id)
-        return self._state.rule_import(importer)
+        return self._state.data_model_import(importer)
 
     def core_data_model(self, concepts: str | list[str]) -> IssueList:
         """Subset the data model to the desired concepts.
@@ -159,7 +159,7 @@ class CDFReadAPI(BaseReadAPI):
         importer: importers.DMSImporter = importers.DMSImporter.from_data_model_id(
             cast(NeatClient, self._state.client), cdm_v1
         )
-        issues = self._state.rule_import(importer)
+        issues = self._state.data_model_import(importer)
 
         if issues.has_errors:
             return issues
@@ -167,7 +167,7 @@ class CDFReadAPI(BaseReadAPI):
         cdm_data_model = self._state.data_model_store.last_verified_data_model
 
         issues.extend(
-            self._state.rule_transform(
+            self._state.data_model_transform(
                 ToEnterpriseModel(
                     new_model_id=("my_space", "MyCDMSubset", "v1"),
                     org_name="CopyOf",
@@ -181,7 +181,7 @@ class CDFReadAPI(BaseReadAPI):
             return issues
 
         issues.extend(
-            self._state.rule_transform(
+            self._state.data_model_transform(
                 _SubsetEditableCDMPhysicalDataModel(
                     views={
                         ViewEntity(
@@ -568,7 +568,7 @@ class ExcelReadAPI(BaseReadAPI):
                 empty_data_model_store_required=True,
             )
 
-        return self._state.rule_import(importers.ExcelImporter(path), enable_manual_edit)
+        return self._state.data_model_import(importers.ExcelImporter(path), enable_manual_edit)
 
 
 @session_class_wrapper
@@ -607,7 +607,7 @@ class YamlReadAPI(BaseReadAPI):
             importer = dms_importer
         else:
             raise NeatValueError(f"Unsupported YAML format: {format}")
-        return self._state.rule_import(importer)
+        return self._state.data_model_import(importer)
 
 
 @session_class_wrapper
@@ -824,7 +824,7 @@ class RDFReadAPI(BaseReadAPI):
 
         reader = NeatReader.create(io)
         importer = importers.OWLImporter.from_file(reader.materialize_path(), source_name=f"file {reader!s}")
-        return self._state.rule_import(importer)
+        return self._state.data_model_import(importer)
 
     def imf(self, io: Any) -> IssueList:
         """Reads IMF Types provided as SHACL shapes into NeatSession.
@@ -847,7 +847,7 @@ class RDFReadAPI(BaseReadAPI):
 
         reader = NeatReader.create(io)
         importer = importers.IMFImporter.from_file(reader.materialize_path(), source_name=f"file {reader!s}")
-        return self._state.rule_import(importer)
+        return self._state.data_model_import(importer)
 
     def instances(self, io: Any) -> IssueList:
         self._state._raise_exception_if_condition_not_met(
@@ -915,7 +915,7 @@ class Examples:
         )
 
         importer: importers.ExcelImporter = importers.ExcelImporter(catalog.hello_world_pump)
-        return self._state.rule_import(importer)
+        return self._state.data_model_import(importer)
 
     def core_data_model(self) -> IssueList:
         """Reads the core data model example into the NeatSession."""
@@ -930,4 +930,4 @@ class Examples:
         importer: importers.DMSImporter = importers.DMSImporter.from_data_model_id(
             cast(NeatClient, self._state.client), cdm_v1
         )
-        return self._state.rule_import(importer)
+        return self._state.data_model_import(importer)

cognite/neat/session/_set.py

@@ -48,7 +48,7 @@ class SetAPI:
                     "Cannot change the data model ID of a Cognite Data Model in NeatSession"
                     " due to temporarily issue with the reverse direct relation interpretation"
                 )
-        return self._state.rule_transform(SetIDDMSModel(new_model_id, name))
+        return self._state.data_model_transform(SetIDDMSModel(new_model_id, name))
 
     def client(self, client: CogniteClient) -> None:
         """Sets the client to be used in the session."""

cognite/neat/session/_state.py

@@ -30,7 +30,7 @@ class SessionState:
         self.client = client
         self.quoted_source_identifiers = False
 
-    def rule_transform(self, *transformer: VerifiedDataModelTransformer) -> IssueList:
+    def data_model_transform(self, *transformer: VerifiedDataModelTransformer) -> IssueList:
         if not transformer:
             raise NeatSessionError("No transformers provided.")
         start = self.data_model_store.provenance[-1].target_entity.display_name
@@ -40,7 +40,7 @@ class SessionState:
         issues.hint = "Use the .inspect.issues() for more details."
         return issues
 
-    def rule_import(self, importer: BaseImporter, enable_manual_edit: bool = False) -> IssueList:
+    def data_model_import(self, importer: BaseImporter, enable_manual_edit: bool = False) -> IssueList:
         issues = self.data_model_store.import_data_model(
             importer,
             client=self.client,

cognite/neat/session/_subset.py

@@ -68,14 +68,14 @@ class SubsetAPI:
                 for concept in concepts
             }
 
-            issues = self._state.rule_transform(SubsetPhysicalDataModel(views=views))
+            issues = self._state.data_model_transform(SubsetPhysicalDataModel(views=views))
             if not issues:
                 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))
+            issues = self._state.data_model_transform(SubsetConceptualDataModel(concepts=classes))
             if not issues:
                 after = len(self._state.data_model_store.last_verified_conceptual_data_model.concepts)
 

cognite/neat/session/_template.py

@@ -70,7 +70,7 @@ class TemplateAPI:
 
         """
         last_dm = self._state.data_model_store.last_verified_data_model
-        issues = self._state.rule_transform(
+        issues = self._state.data_model_transform(
             ToEnterpriseModel(
                 new_model_id=data_model_id,
                 org_name=org_name,
@@ -122,7 +122,7 @@ class TemplateAPI:
 
         transformers.append(ToDataProductModel(new_model_id=data_model_id, include=include))
 
-        issues = self._state.rule_transform(*transformers)
+        issues = self._state.data_model_transform(*transformers)
         if last_dm and not issues.has_errors:
             self._state.last_reference = last_dm
         return issues
@@ -202,7 +202,7 @@ class TemplateAPI:
                     ExcelExporter(styling="maximal").export_to_file(info, output_path)
         issues.action = "Created extension template"
 
-        # Adding issues to the state in the rule store
+        # Adding issues to the state in the data model store
         if issues:
             self._state.data_model_store._last_issues = issues
         return issues

cognite/neat/session/_to.py

@@ -311,34 +311,37 @@ class CDFToAPI:
 
         client = cast(NeatClient, self._state.client)
         physical_data_model = self._state.data_model_store.last_verified_physical_data_model
-        instance_space = instance_space or f"{physical_data_model.metadata.space}_instances"
 
         if instance_space and instance_space == physical_data_model.metadata.space:
             raise NeatSessionError("Space for instances must be different from the data model space.")
         elif not PATTERNS.space_compliance.match(str(instance_space)):
             raise NeatSessionError("Please provide a valid space name. {PATTERNS.space_compliance.pattern}")
 
-        if not client.data_modeling.spaces.retrieve(instance_space):
-            client.data_modeling.spaces.apply(dm.SpaceApply(space=instance_space))
+        instance_space_loader = loaders.InstanceSpaceLoader(
+            self._state.instances.store,
+            instance_space=instance_space,
+            space_property=space_from_property,
+            use_source_space=use_source_space,
+            neat_prefix_by_predicate_uri=self._state.instances.neat_prefix_by_predicate_uri,
+        )
+        result = instance_space_loader.load_into_cdf(client)
 
         loader = loaders.DMSLoader(
             self._state.data_model_store.last_verified_physical_data_model,
             self._state.data_model_store.last_verified_conceptual_data_model,
             self._state.instances.store,
-            instance_space=instance_space,
+            space_by_instance_uri=instance_space_loader.space_by_instance_uri,
             client=client,
-            space_property=space_from_property,
-            use_source_space=use_source_space,
             # In case urllib.parse.quote() was run on the extraction, we need to run
             # urllib.parse.unquote() on the load.
             unquote_external_ids=True,
-            neat_prefix_by_predicate_uri=self._state.instances.neat_prefix_by_predicate_uri,
             neat_prefix_by_type_uri=self._state.instances.neat_prefix_by_type_uri,
         )
 
-        result = loader.load_into_cdf(client)
-        self._state.instances.outcome.append(result)
+        instance_result = loader.load_into_cdf(client)
         print("You can inspect the details with the .inspect.outcome.instances(...) method.")
+        result.extend(instance_result)
+        self._state.instances.outcome.append(result)
         return result
 
     def data_model(
@@ -419,22 +422,26 @@ class ToPythonAPI:
             ```
         """
         physical_data_model = self._state.data_model_store.last_verified_physical_data_model
-        instance_space = instance_space or f"{physical_data_model.metadata.space}_instances"
 
         if instance_space and instance_space == physical_data_model.metadata.space:
             raise NeatSessionError("Space for instances must be different from the data model space.")
         elif not PATTERNS.space_compliance.match(str(instance_space)):
             raise NeatSessionError(f"Please provide a valid space name. {PATTERNS.space_compliance.pattern}")
 
-        loader = loaders.DMSLoader(
-            self._state.data_model_store.last_verified_physical_data_model,
-            self._state.data_model_store.last_verified_conceptual_data_model,
+        instance_loader = loaders.InstanceSpaceLoader(
             self._state.instances.store,
             instance_space=instance_space,
             space_property=space_from_property,
             use_source_space=use_source_space,
-            unquote_external_ids=True,
             neat_prefix_by_predicate_uri=self._state.instances.neat_prefix_by_predicate_uri,
+        )
+
+        loader = loaders.DMSLoader(
+            self._state.data_model_store.last_verified_physical_data_model,
+            self._state.data_model_store.last_verified_conceptual_data_model,
+            self._state.instances.store,
+            space_by_instance_uri=instance_loader.space_by_instance_uri,
+            unquote_external_ids=True,
             neat_prefix_by_type_uri=self._state.instances.neat_prefix_by_type_uri,
         )
         issue_list = IssueList()

{cognite_neat-0.122.1.dist-info → cognite_neat-0.122.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 0.122.1
+Version: 0.122.2
 Summary: Knowledge graph transformation
 Project-URL: Documentation, https://cognite-neat.readthedocs-hosted.com/
 Project-URL: Homepage, https://cognite-neat.readthedocs-hosted.com/

{cognite_neat-0.122.1.dist-info → cognite_neat-0.122.2.dist-info}/RECORD

@@ -1,5 +1,5 @@
 cognite/neat/__init__.py,sha256=12StS1dzH9_MElqxGvLWrNsxCJl9Hv8A2a9D0E5OD_U,193
-cognite/neat/_version.py,sha256=hEX04Zd5WV2gLQgKwCOdCPXl2IszZNRZ4q4_HQXhmwM,46
+cognite/neat/_version.py,sha256=_JrRkMfRe7BY5PWfWWx60wpSBwtlRhSaJ8zbSR9WYtc,46
 cognite/neat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/core/_config.py,sha256=WT1BS8uADcFvGoUYOOfwFOVq_VBl472TisdoA3wLick,280
@@ -38,7 +38,7 @@ cognite/neat/core/_data_model/importers/__init__.py,sha256=ipImLDSse0vAHX4AWvtPI
 cognite/neat/core/_data_model/importers/_base.py,sha256=pKe2OK86Wdj6CTj5bUgjY33ejZhRfD2eJbjcCapHD58,2013
 cognite/neat/core/_data_model/importers/_base_file_reader.py,sha256=m7CwMujEybYMfHWbTQOb7wBvLl2X1TmROkPelJMSaDA,1621
 cognite/neat/core/_data_model/importers/_dict2data_model.py,sha256=-1zmo8JkxJ9qiWuC7sUH7oSlpnPPKTMxZtm4WrRPO5A,4709
-cognite/neat/core/_data_model/importers/_dms2data_model.py,sha256=wDtCikD2qEZgl1SWBQ6qIClPXOZVmHNN7HUNaChoWIQ,28294
+cognite/neat/core/_data_model/importers/_dms2data_model.py,sha256=fbPf1IA5wAZtosSYe8sd4Tnur3w41TTJz2qRbTHX-d0,28306
 cognite/neat/core/_data_model/importers/_spreadsheet2data_model.py,sha256=2QqrxQ9AI3LT9toH_gryIR52UecMsR-v44ljXedDCp4,11972
 cognite/neat/core/_data_model/importers/_dtdl2data_model/__init__.py,sha256=CNR-sUihs2mnR1bPMKs3j3L4ds3vFTsrl6YycExZTfU,68
 cognite/neat/core/_data_model/importers/_dtdl2data_model/_unit_lookup.py,sha256=wW4saKva61Q_i17guY0dc4OseJDQfqHy_QZBtm0OD6g,12134
@@ -77,9 +77,9 @@ cognite/neat/core/_data_model/models/physical/_validation.py,sha256=i0YHDE2c09Oe
 cognite/neat/core/_data_model/models/physical/_verified.py,sha256=UsfzuIyYRsdUPK9wJM9Wxs4VkD4GiGUQAjRjgDCmIHw,24237
 cognite/neat/core/_data_model/transformers/__init__.py,sha256=_FPmPh0kA68SXR4arKKNmtWQ8B2-wSwWQeGAWnjoJAQ,1788
 cognite/neat/core/_data_model/transformers/_base.py,sha256=7adUBJgDkXgRq_h7l1q2VsLQo3lE7-xmzmHdcF4QHq8,3133
-cognite/neat/core/_data_model/transformers/_converters.py,sha256=JPUzZks6lqKd8hg809K8Anj7lC5cu3jTdmaShcZhDsc,111569
-cognite/neat/core/_data_model/transformers/_mapping.py,sha256=oIabTo7fN21wTq5Tlf2bour3xC52lqIrqrkH91nKHb4,19018
-cognite/neat/core/_data_model/transformers/_verification.py,sha256=CKeNMcOFFwUu9nAASLNySrfhWTkwxwkE0aOBZA5XqU8,5187
+cognite/neat/core/_data_model/transformers/_converters.py,sha256=OazYC7DgAXXEvxdiaPfJSe2ZNkYn2mRqWhtvtvWK59g,111575
+cognite/neat/core/_data_model/transformers/_mapping.py,sha256=GwmTRnhiUPIG37CgUSIbjT7ZpWOwdWuBZ_HAIIBiKYY,19024
+cognite/neat/core/_data_model/transformers/_verification.py,sha256=yyPK6irhMGjVtwKxRIElSsPLUvLLVfk1lBAGny6jN5w,5193
 cognite/neat/core/_instances/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/core/_instances/_shared.py,sha256=6avH6mtjxjHI7JDLkXwICxGvZwooGBr6APs1_w1To-A,940
 cognite/neat/core/_instances/_tracking/__init__.py,sha256=WOwsYieZtCW-iW15YkxUFrfKVVdLWdXHOGGStTwvE8A,91
@@ -108,13 +108,14 @@ cognite/neat/core/_instances/extractors/_classic_cdf/_labels.py,sha256=7guTZdGFT
 cognite/neat/core/_instances/extractors/_classic_cdf/_relationships.py,sha256=kNzrqHQuIZMBecZ8957Qs3-Pp2m2-k2CCfiUZlVwaD0,5395
 cognite/neat/core/_instances/extractors/_classic_cdf/_sequences.py,sha256=zwHM52afnq-JHvLOTi4rH6DyfkTftxH6cmODwoZi8uw,11399
 cognite/neat/core/_instances/extractors/_classic_cdf/_timeseries.py,sha256=Py8MDcn82MJcsDPbeqDHMx4g2rQHmEOSHNe6gOi5gew,2044
-cognite/neat/core/_instances/loaders/__init__.py,sha256=XS6vwmxgBzntg7UuG_ct_1hfhShVnFH5u0gGrdA8WfA,699
-cognite/neat/core/_instances/loaders/_base.py,sha256=v2sSR8wc8_vt5X_VioXctHj9XUxWxapeE7LChL1fPQ0,4512
-cognite/neat/core/_instances/loaders/_rdf2dms.py,sha256=3QZzZ6oJn6toMk9-yWPtZiEEdW8wYW998nN6Drvu20I,34510
+cognite/neat/core/_instances/loaders/__init__.py,sha256=qyOrKy0cJgYmgEuWVM-O1mpUemQE8EkfQYtJyEc8UVs,778
+cognite/neat/core/_instances/loaders/_base.py,sha256=jfik8xsdocMHVlodvgHpnDJfYdEjYuKdd0t7MGhzAHI,4337
+cognite/neat/core/_instances/loaders/_rdf2dms.py,sha256=PoNj77pxVoUpP7qxmMWf2nNul2PtlAlIFcVzUV2gyuE,29076
+cognite/neat/core/_instances/loaders/_rdf_to_instance_space.py,sha256=qVxRzEUyhv8AGvAO8whJWPCZ-8BppEy0mk1Ux_8gOzY,11937
 cognite/neat/core/_instances/queries/__init__.py,sha256=W477LMyB4l6HIRbQhJoFgA_MUBwVCh2GBvtFeZu0AUA,53
 cognite/neat/core/_instances/queries/_base.py,sha256=APevHeeWQDEoOQ0MlBtVlPf9hbZukVkI5fOvt5oPJCE,543
 cognite/neat/core/_instances/queries/_queries.py,sha256=4BidSQXhdZYZ6_kyG7jMJ2iG0UtSrbQxfmwPM7V167A,466
-cognite/neat/core/_instances/queries/_select.py,sha256=ah4F03SJLUVsn_Fw4NHDi1KtiMXYNXpMYlalqW7eK_E,18533
+cognite/neat/core/_instances/queries/_select.py,sha256=-iJnEddNCIr26D2QBBq_82G4l6YoYpTs2jd_CELvxB8,19096
 cognite/neat/core/_instances/queries/_update.py,sha256=j2hU62rEIYWvZ_ZAkm9Khc2lNddnww0W-1jR7MJJbFY,1290
 cognite/neat/core/_instances/transformers/__init__.py,sha256=YzC1Z8BuT77NwagWX4Z-F9R9BARLSS7zM4bCdxBbqKg,1761
 cognite/neat/core/_instances/transformers/_base.py,sha256=RYa9es5fEsjLpaok8liuy73ACPDWwHVfTm2Lq4HVCig,4695
@@ -160,22 +161,22 @@ cognite/neat/core/_utils/xml_.py,sha256=FQkq84u35MUsnKcL6nTMJ9ajtG9D5i1u4VBnhGqP
 cognite/neat/core/_utils/reader/__init__.py,sha256=fPkrNB_9hLB7CyHTCFV_xEbIfOMqUQzNly5JN33-QfM,146
 cognite/neat/core/_utils/reader/_base.py,sha256=fRXxUWW8a3UFedeCLxDTDgFntWGlHaEGxmKLcITtiWE,5417
 cognite/neat/session/__init__.py,sha256=fxQ5URVlUnmEGYyB8Baw7IDq-uYacqkigbc4b-Pr9Fw,58
-cognite/neat/session/_base.py,sha256=eR4E0xixBnTJ7OofnqCWXH7-84gv5iKQG06dP1_5LEE,12795
+cognite/neat/session/_base.py,sha256=DqujVyC19Jg8hGxnw9TfCeF3BYOFuauk4yTTuAsjJz4,12807
 cognite/neat/session/_collector.py,sha256=-icWXOT9YBjAOVZfpPtBx-D39kpRP2RaQKdPtcr7Xm8,4233
-cognite/neat/session/_drop.py,sha256=mCJISS73e-q3Ioj2cGXZwCpEHzKGiJ8Z5D8Uuk0yWOQ,4233
+cognite/neat/session/_drop.py,sha256=ipD8RS_ZebPNpeIkhC7yqSSeo7e57TXMRxrh5_6IRik,4239
 cognite/neat/session/_experimental.py,sha256=U_Wq3NWgnGaOJh5Fq8iO6HcYUhlG9RQIutT8e4LZL8o,1224
 cognite/neat/session/_explore.py,sha256=PLxpHDqBk5B0Q4a5tJKnF6KzL4heQ77b2qUETbf6iVQ,1599
-cognite/neat/session/_fix.py,sha256=9XrNIH1Zw4DI0HDH3XqnI2c-us4V0CyZpoM_Mtt2H0g,913
+cognite/neat/session/_fix.py,sha256=oJRXuRI4f_HgLYHkjbtPAwHK0vSDUYd19hIZeFaE7rQ,919
 cognite/neat/session/_inspect.py,sha256=AESQd2SOidR_pDTFk5B_JdPnKZ5PNNskdAQBepH2Mv0,10175
-cognite/neat/session/_mapping.py,sha256=KlFjRq5JUZ_FV4AI7H6RSLZw6_fzhtTe0C1vzqkvSNg,2889
-cognite/neat/session/_prepare.py,sha256=xa-35JKgi1j8X347ub6komEMNGFjytPaQReFOgeFHnA,12760
-cognite/neat/session/_read.py,sha256=bzmsSUmap8IUit1bmwjip6h3is4nQSSIK8ygWVYxM_o,35289
-cognite/neat/session/_set.py,sha256=785duIx09hlC3JZGC7kd1qZOEa1Rh8yoTIXP5ppqypU,4587
+cognite/neat/session/_mapping.py,sha256=ItEXhXo_8V3069hktHMxdpBsLNeTck3gZBvhlm12Oxw,2895
+cognite/neat/session/_prepare.py,sha256=pskEVNgcnVJVRvYKk5xI55V89vKDO_kgjszj5flY8Zs,12778
+cognite/neat/session/_read.py,sha256=sKtSw7Ub--vR6wfEexNzzaEHb0MZCHj3kzCEnF5wjf0,35349
+cognite/neat/session/_set.py,sha256=PU4lKI-LGtKFVyvdtfZkk-zLw9e_rnFHzuV9IyrOrTM,4593
 cognite/neat/session/_show.py,sha256=YLt6K4ukG1s_I_FhuVrIVPtw_btvvOL50Rwrx-vo7VQ,10743
-cognite/neat/session/_state.py,sha256=rhH7LJvwcsdVUYB7BnLINItUjfuGHuTyfBPsjNhIV0w,6568
-cognite/neat/session/_subset.py,sha256=CwbO7wpAbNmD5rz8NYsUjx-1NS3fjZ2h9LJ7UwN1-mM,2836
-cognite/neat/session/_template.py,sha256=OjDD2HLQuCdKBevbaxLv2JAI1EQFB_EDIH5glq44L9o,9890
-cognite/neat/session/_to.py,sha256=zOguyrMtk08uMwzuXzAeRLQ_833EHKmwz6ovy3Si-Dc,19257
+cognite/neat/session/_state.py,sha256=DLEm9wn3GtOuTGhy5-M1IK2v9qvLnTYEruWPidzAP_Q,6580
+cognite/neat/session/_subset.py,sha256=p7n6WmL0gZlUbqpVBgyPncQ6uWn_pi7FDSixDFrm7DM,2848
+cognite/neat/session/_template.py,sha256=NCgrrwLT98DpLYoo3Wybr_OUXrEXpsJZjrJ83KqfyWc,9908
+cognite/neat/session/_to.py,sha256=_R-UB3iEIQoa12kTD7tuSrRDdbySQXQg_mzbn5t-7bg,19399
 cognite/neat/session/_wizard.py,sha256=hARNNzD5Zfkk_V147rIjOLVvrFaqzXGXWhZuH1NJG3M,1486
 cognite/neat/session/exceptions.py,sha256=KJ7UUjmuGb_1O6FIamkwe4z0bCroAwn-AwX---hEudY,3341
 cognite/neat/session/_state/README.md,sha256=o6N7EL98lgyWffw8IoEUf2KG5uSKveD5__TW45YzVjA,902
@@ -183,7 +184,7 @@ cognite/neat/session/engine/__init__.py,sha256=D3MxUorEs6-NtgoICqtZ8PISQrjrr4dvc
 cognite/neat/session/engine/_import.py,sha256=1QxA2_EK613lXYAHKQbZyw2yjo5P9XuiX4Z6_6-WMNQ,169
 cognite/neat/session/engine/_interface.py,sha256=3W-cYr493c_mW3P5O6MKN1xEQg3cA7NHR_ev3zdF9Vk,533
 cognite/neat/session/engine/_load.py,sha256=g52uYakQM03VqHt_RDHtpHso1-mFFifH5M4T2ScuH8A,5198
-cognite_neat-0.122.1.dist-info/METADATA,sha256=D25cVsvDJ6cWBPH9guOTr-xHC016LePV1cajgQFAwZ4,9171
-cognite_neat-0.122.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cognite_neat-0.122.1.dist-info/licenses/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
-cognite_neat-0.122.1.dist-info/RECORD,,
+cognite_neat-0.122.2.dist-info/METADATA,sha256=_QX6C2C4GLJTwqISRsJcrNIFpPZbxTXi6OLbwc_hDhg,9171
+cognite_neat-0.122.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cognite_neat-0.122.2.dist-info/licenses/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
+cognite_neat-0.122.2.dist-info/RECORD,,