cognite-neat 0.122.1__tar.gz → 0.122.3__tar.gz

{cognite_neat-0.122.1 → cognite_neat-0.122.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 0.122.1
+Version: 0.122.3
 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.3/cognite/neat/_version.py

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

{cognite_neat-0.122.1 → cognite_neat-0.122.3}/cognite/neat/core/_data_model/importers/_dms2data_model.py

@@ -68,6 +68,7 @@ from cognite.neat.core._issues import (
     catch_issues,
 )
 from cognite.neat.core._issues.errors import (
+    FileNotFoundNeatError,
     FileTypeUnexpectedError,
     NeatValueError,
     PropertyTypeNotSupportedError,
@@ -254,7 +255,7 @@ class DMSImporter(BaseImporter[UnverifiedPhysicalDataModel]):
         elif path.is_dir():
             return cls.from_directory(path, client)
         else:
-            raise NeatValueError(f"Unsupported YAML format: {format}")
+            raise FileNotFoundNeatError(path)
 
     def to_data_model(self) -> ImportedDataModel[UnverifiedPhysicalDataModel]:
         if self.issue_list.has_errors:
@@ -269,14 +270,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-0.122.1 → cognite_neat-0.122.3}/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-0.122.1 → cognite_neat-0.122.3}/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-0.122.1 → cognite_neat-0.122.3}/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-0.122.1 → cognite_neat-0.122.3}/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-0.122.1 → cognite_neat-0.122.3}/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-0.122.1 → cognite_neat-0.122.3}/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-0.122.3/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