cognite-neat 0.97.0__tar.gz → 0.97.2__tar.gz

{cognite_neat-0.97.0 → cognite_neat-0.97.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cognite-neat
-Version: 0.97.0
+Version: 0.97.2
 Summary: Knowledge graph transformation
 Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0
@@ -28,7 +28,7 @@ Requires-Dist: google-api-python-client ; extra == "google"
 Requires-Dist: google-auth-oauthlib ; extra == "google"
 Requires-Dist: gspread ; extra == "google"
 Requires-Dist: jsonpath-python (>=1.0.6,<2.0.0)
-Requires-Dist: lxml (>=5.3.0,<6.0.0)
+Requires-Dist: lxml (>=5.3.0,<6.0.0) ; extra == "all"
 Requires-Dist: mkdocs ; extra == "docs"
 Requires-Dist: mkdocs-autorefs (>=0.5.0,<0.6.0) ; extra == "docs"
 Requires-Dist: mkdocs-git-authors-plugin ; extra == "docs"

{cognite_neat-0.97.0 → cognite_neat-0.97.2}/cognite/neat/_graph/loaders/_base.py

@@ -51,7 +51,14 @@ class CDFLoader(BaseLoader[T_Output]):
     def load_into_cdf(
         self, client: CogniteClient, dry_run: bool = False, check_client: bool = True
     ) -> UploadResultList:
-        return UploadResultList(self.load_into_cdf_iterable(client, dry_run, check_client))
+        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):
+                upload_result_by_name[upload_result.name] = last_result.merge(upload_result)
+            else:
+                upload_result_by_name[upload_result.name] = upload_result
+
+        return UploadResultList(upload_result_by_name.values())
 
     def load_into_cdf_iterable(
         self, client: CogniteClient, dry_run: bool = False, check_client: bool = True

{cognite_neat-0.97.0 → cognite_neat-0.97.2}/cognite/neat/_graph/loaders/_rdf2dms.py

@@ -1,3 +1,4 @@
+import itertools
 import json
 from collections.abc import Iterable, Sequence
 from pathlib import Path
@@ -295,9 +296,24 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         dry_run: bool,
         read_issues: IssueList,
     ) -> Iterable[UploadResult]:
+        nodes: list[dm.NodeApply] = []
+        edges: list[dm.EdgeApply] = []
+        source_by_node_id: dict[dm.NodeId, str] = {}
+        source_by_edge_id: dict[dm.EdgeId, str] = {}
+        for item in items:
+            if isinstance(item, dm.NodeApply):
+                nodes.append(item)
+                if item.sources:
+                    source_by_node_id[item.as_id()] = item.sources[0].source.external_id
+                else:
+                    source_by_node_id[item.as_id()] = "node"
+            elif isinstance(item, dm.EdgeApply):
+                edges.append(item)
+                if item.sources:
+                    source_by_edge_id[item.as_id()] = item.sources[0].source.external_id
+                else:
+                    source_by_edge_id[item.as_id()] = "edge"
         try:
-            nodes = [item for item in items if isinstance(item, dm.NodeApply)]
-            edges = [item for item in items if isinstance(item, dm.EdgeApply)]
             upserted = client.data_modeling.instances.apply(
                 nodes,
                 edges,
@@ -312,19 +328,23 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             result.created.update(item.as_id() for item in e.successful)
             yield result
         else:
-            for instance_type, instances in {
-                "Nodes": upserted.nodes,
-                "Edges": upserted.edges,
-            }.items():
-                result = UploadResult[InstanceId](name=instance_type, issues=read_issues)
-                for instance in instances:  # type: ignore[attr-defined]
-                    if instance.was_modified and instance.created_time == instance.last_updated_time:
-                        result.created.add(instance.as_id())
-                    elif instance.was_modified:
-                        result.changed.add(instance.as_id())
-                    else:
-                        result.unchanged.add(instance.as_id())
-                yield result
+            for instances, ids_by_source in [
+                (upserted.nodes, source_by_node_id),
+                (upserted.edges, source_by_edge_id),
+            ]:
+                for name, subinstances in itertools.groupby(
+                    sorted(instances, key=lambda i: ids_by_source[i.as_id()]),  # type: ignore[call-overload, index, attr-defined]
+                    key=lambda i: ids_by_source[i.as_id()],  # type: ignore[index]
+                ):
+                    result = UploadResult(name=name, issues=read_issues)
+                    for instance in subinstances:  # type: ignore[attr-defined]
+                        if instance.was_modified and instance.created_time == instance.last_updated_time:
+                            result.created.add(instance.as_id())
+                        elif instance.was_modified:
+                            result.changed.add(instance.as_id())
+                        else:
+                            result.unchanged.add(instance.as_id())
+                    yield result
 
 
 def _get_field_value_types(cls, info):

{cognite_neat-0.97.0 → cognite_neat-0.97.2}/cognite/neat/_issues/__init__.py

@@ -3,12 +3,14 @@ as some helper classes to handle them like NeatIssueList"""
 
 from ._base import (
     DefaultWarning,
+    FutureResult,
     IssueList,
     MultiValueError,
     NeatError,
     NeatIssue,
     NeatIssueList,
     NeatWarning,
+    catch_issues,
     catch_warnings,
 )
 
@@ -21,4 +23,6 @@ __all__ = [
     "IssueList",
     "MultiValueError",
     "catch_warnings",
+    "catch_issues",
+    "FutureResult",
 ]

{cognite_neat-0.97.0 → cognite_neat-0.97.2}/cognite/neat/_issues/_base.py

@@ -18,6 +18,7 @@ from cognite.client.data_classes.data_modeling import (
     PropertyId,
     ViewId,
 )
+from pydantic import ValidationError
 from pydantic_core import ErrorDetails
 
 from cognite.neat._utils.spreadsheet import SpreadsheetRead
@@ -398,6 +399,10 @@ class NeatIssueList(list, Sequence[T_NeatIssue], ABC):
         """Return all the warnings in this list."""
         return type(self)([issue for issue in self if isinstance(issue, NeatWarning)])  # type: ignore[misc]
 
+    def has_error_type(self, error_type: type[NeatError]) -> bool:
+        """Return True if this list contains any errors of the given type."""
+        return any(isinstance(issue, error_type) for issue in self)
+
     def as_errors(self, operation: str = "Operation failed") -> ExceptionGroup:
         """Return an ExceptionGroup with all the errors in this list."""
         return ExceptionGroup(
@@ -473,3 +478,46 @@ def catch_warnings(
         finally:
             if warning_logger and issues is not None:
                 issues.extend([warning_cls.from_warning(warning) for warning in warning_logger])  # type: ignore[misc]
+
+
+class FutureResult:
+    def __init__(self) -> None:
+        self._result: Literal["success", "failure", "pending"] = "pending"
+
+    @property
+    def result(self) -> Literal["success", "failure", "pending"]:
+        return self._result
+
+
+@contextmanager
+def catch_issues(
+    issues: IssueList,
+    error_cls: type[NeatError] = NeatError,
+    warning_cls: type[NeatWarning] = NeatWarning,
+    error_args: dict[str, Any] | None = None,
+) -> Iterator[FutureResult]:
+    """This is an internal help function to handle issues and warnings.
+
+    Args:
+        issues: The issues list to append to.
+        error_cls: The class used to convert errors to issues.
+        warning_cls:  The class used to convert warnings to issues.
+
+    Returns:
+        FutureResult: A future result object that can be used to check the result of the context manager.
+    """
+    with catch_warnings(issues, warning_cls):
+        future_result = FutureResult()
+        try:
+            yield future_result
+        except ValidationError as e:
+            issues.extend(error_cls.from_pydantic_errors(e.errors(), **(error_args or {})))
+            future_result._result = "failure"
+        except MultiValueError as e:
+            issues.extend(e.errors)
+            future_result._result = "failure"
+        except NeatError as e:
+            issues.append(e)
+            future_result._result = "failure"
+        else:
+            future_result._result = "success"

{cognite_neat-0.97.0 → cognite_neat-0.97.2}/cognite/neat/_issues/errors/_general.py

@@ -19,10 +19,12 @@ class NeatTypeError(NeatError, TypeError):
 
 @dataclass(unsafe_hash=True)
 class RegexViolationError(NeatError, ValueError):
-    """Value, {value} failed regex, {regex}, validation. Make sure that the name follows the regex pattern."""
+    """Value, {value} in {location} failed regex, {regex}, validation.
+    Make sure that the name follows the regex pattern."""
 
     value: str
     regex: str
+    location: str
 
 
 @dataclass(unsafe_hash=True)

{cognite_neat-0.97.0 → cognite_neat-0.97.2}/cognite/neat/_rules/models/_types.py

@@ -76,13 +76,17 @@ NamespaceType = Annotated[
 PrefixType = Annotated[
     str,
     StringConstraints(pattern=PREFIX_COMPLIANCE_REGEX),
-    _custom_error(lambda _, value: RegexViolationError(value, PREFIX_COMPLIANCE_REGEX)),
+    _custom_error(
+        lambda _, value: RegexViolationError(value, PREFIX_COMPLIANCE_REGEX, "prefix entry in metadata"),
+    ),
 ]
 
 DataModelExternalIdType = Annotated[
     str,
     StringConstraints(pattern=DATA_MODEL_COMPLIANCE_REGEX),
-    _custom_error(lambda _, value: RegexViolationError(value, DATA_MODEL_COMPLIANCE_REGEX)),
+    _custom_error(
+        lambda _, value: RegexViolationError(value, DATA_MODEL_COMPLIANCE_REGEX, "external ID entry in metadata")
+    ),
 ]
 
 
@@ -90,15 +94,15 @@ VersionType = Annotated[
     str,
     BeforeValidator(str),
     StringConstraints(pattern=VERSION_COMPLIANCE_REGEX),
-    _custom_error(lambda _, value: RegexViolationError(value, VERSION_COMPLIANCE_REGEX)),
+    _custom_error(lambda _, value: RegexViolationError(value, VERSION_COMPLIANCE_REGEX, "version entry in metadata")),
 ]
 
 
-def _external_id_validation_factory(entity_type: EntityTypes):
+def _external_id_validation_factory(entity_type: EntityTypes, location: str):
     def _external_id_validation(value: str) -> str:
         compiled_regex = PATTERNS.entity_pattern(entity_type)
         if not compiled_regex.match(value):
-            raise RegexViolationError(value, compiled_regex.pattern)
+            raise RegexViolationError(value, compiled_regex.pattern, location)
         if PATTERNS.more_than_one_alphanumeric.search(value):
             warnings.warn(
                 RegexViolationWarning(
@@ -116,36 +120,40 @@ def _external_id_validation_factory(entity_type: EntityTypes):
 
 SpaceType = Annotated[
     str,
-    AfterValidator(_external_id_validation_factory(EntityTypes.space)),
+    AfterValidator(_external_id_validation_factory(EntityTypes.space, "space entry in metadata")),
 ]
 
 InformationPropertyType = Annotated[
     str,
-    AfterValidator(_external_id_validation_factory(EntityTypes.information_property)),
+    AfterValidator(_external_id_validation_factory(EntityTypes.information_property, "Property column in properties")),
 ]
 DmsPropertyType = Annotated[
     str,
-    AfterValidator(_external_id_validation_factory(EntityTypes.dms_property)),
+    AfterValidator(_external_id_validation_factory(EntityTypes.dms_property, "Property column in properties")),
 ]
 
 
-def _entity_validation(value: Entities) -> Entities:
+def _entity_validation(value: Entities, location: str) -> Entities:
     suffix_regex = PATTERNS.entity_pattern(value.type_)
     if not suffix_regex.match(value.suffix):
-        raise RegexViolationError(str(value), suffix_regex.pattern)
+        raise RegexViolationError(str(value), suffix_regex.pattern, location)
     return value
 
 
-ClassEntityType = Annotated[ClassEntity, AfterValidator(_entity_validation)]
-ViewEntityType = Annotated[ViewEntity, AfterValidator(_entity_validation)]
-ContainerEntityType = Annotated[ContainerEntity, AfterValidator(_entity_validation)]
+ClassEntityType = Annotated[ClassEntity, AfterValidator(lambda v: _entity_validation(v, "the Class column"))]
+ViewEntityType = Annotated[ViewEntity, AfterValidator(lambda v: _entity_validation(v, "the View column"))]
+ContainerEntityType = Annotated[
+    ContainerEntity, AfterValidator(lambda v: _entity_validation(v, "the Container column"))
+]
 
 
-def _multi_value_type_validation(value: MultiValueTypeInfo) -> MultiValueTypeInfo:
+def _multi_value_type_validation(value: MultiValueTypeInfo, location: str) -> MultiValueTypeInfo:
     for type_ in value.types:
         if isinstance(type_, ClassEntity):
-            _entity_validation(type_)
+            _entity_validation(type_, location)
     return value
 
 
-MultiValueTypeType = Annotated[MultiValueTypeInfo, AfterValidator(_multi_value_type_validation)]
+MultiValueTypeType = Annotated[
+    MultiValueTypeInfo, AfterValidator(lambda v: _multi_value_type_validation(v, "the Value Type column"))
+]

{cognite_neat-0.97.0 → cognite_neat-0.97.2}/cognite/neat/_rules/transformers/_verification.py

@@ -1,11 +1,7 @@
 from abc import ABC
-from collections.abc import Iterator
-from contextlib import contextmanager
 from typing import Any, Literal
 
-from pydantic import ValidationError
-
-from cognite.neat._issues import IssueList, MultiValueError, NeatError, NeatWarning, catch_warnings
+from cognite.neat._issues import IssueList, NeatError, NeatWarning, catch_issues
 from cognite.neat._issues.errors import NeatTypeError
 from cognite.neat._rules._shared import (
     InputRules,
@@ -45,7 +41,7 @@ class VerificationTransformer(RulesTransformer[T_InputRules, T_VerifiedRules], A
         if isinstance(rules, ReadRules):
             error_args = rules.read_context
         verified_rules: T_VerifiedRules | None = None
-        with _catch_issues(issues, NeatError, NeatWarning, error_args) as future:
+        with catch_issues(issues, NeatError, NeatWarning, error_args) as future:
             rules_cls = self._get_rules_cls(in_)
             verified_rules = rules_cls.model_validate(in_.dump())  # type: ignore[assignment]
 
@@ -92,46 +88,3 @@ class VerifyAnyRules(VerificationTransformer[InputRules, VerifiedRules]):
             return DomainRules
         else:
             raise NeatTypeError(f"Unsupported rules type: {type(in_)}")
-
-
-class _FutureResult:
-    def __init__(self) -> None:
-        self._result: Literal["success", "failure", "pending"] = "pending"
-
-    @property
-    def result(self) -> Literal["success", "failure", "pending"]:
-        return self._result
-
-
-@contextmanager
-def _catch_issues(
-    issues: IssueList,
-    error_cls: type[NeatError] = NeatError,
-    warning_cls: type[NeatWarning] = NeatWarning,
-    error_args: dict[str, Any] | None = None,
-) -> Iterator[_FutureResult]:
-    """This is an internal help function to handle issues and warnings.
-
-    Args:
-        issues: The issues list to append to.
-        error_cls: The class used to convert errors to issues.
-        warning_cls:  The class used to convert warnings to issues.
-
-    Returns:
-        FutureResult: A future result object that can be used to check the result of the context manager.
-    """
-    with catch_warnings(issues, warning_cls):
-        future_result = _FutureResult()
-        try:
-            yield future_result
-        except ValidationError as e:
-            issues.extend(error_cls.from_pydantic_errors(e.errors(), **(error_args or {})))
-            future_result._result = "failure"
-        except MultiValueError as e:
-            issues.extend(e.errors)
-            future_result._result = "failure"
-        except NeatError as e:
-            issues.append(e)
-            future_result._result = "failure"
-        else:
-            future_result._result = "success"

{cognite_neat-0.97.0 → cognite_neat-0.97.2}/cognite/neat/_session/_base.py

@@ -5,9 +5,10 @@ from cognite.client import CogniteClient
 from cognite.client import data_modeling as dm
 
 from cognite.neat import _version
-from cognite.neat._issues import IssueList
+from cognite.neat._issues import IssueList, catch_issues
+from cognite.neat._issues.errors import RegexViolationError
 from cognite.neat._rules import importers
-from cognite.neat._rules._shared import ReadRules
+from cognite.neat._rules._shared import ReadRules, VerifiedRules
 from cognite.neat._rules.importers._rdf._base import DEFAULT_NON_EXISTING_NODE_TYPE
 from cognite.neat._rules.models import DMSRules
 from cognite.neat._rules.models.data_types import AnyURI
@@ -15,6 +16,7 @@ from cognite.neat._rules.models.entities._single_value import UnknownEntity
 from cognite.neat._rules.models.information._rules import InformationRules
 from cognite.neat._rules.models.information._rules_input import InformationInputRules
 from cognite.neat._rules.transformers import ConvertToRules, VerifyAnyRules
+from cognite.neat._rules.transformers._converters import ConversionTransformer
 from cognite.neat._store._provenance import (
     INSTANCES_ENTITY,
     Change,
@@ -85,35 +87,52 @@ class NeatSession:
             print("You can inspect the issues with the .inspect.issues(...) method.")
         return output.issues
 
-    def convert(self, target: Literal["dms", "information"]) -> None:
+    def convert(self, target: Literal["dms", "information"]) -> IssueList:
         start = datetime.now(timezone.utc)
-        if target == "dms":
-            source_id, info_rules = self._state.data_model.last_verified_information_rules
-            converter = ConvertToRules(DMSRules)
-            converted_rules = converter.transform(info_rules).rules
-        elif target == "information":
-            source_id, dms_rules = self._state.data_model.last_verified_dms_rules
-            converter = ConvertToRules(InformationRules)
-            converted_rules = converter.transform(dms_rules).rules
-        else:
-            raise NeatSessionError(f"Target {target} not supported.")
+        issues = IssueList()
+        converter: ConversionTransformer | None = None
+        converted_rules: VerifiedRules | None = None
+        with catch_issues(issues):
+            if target == "dms":
+                source_id, info_rules = self._state.data_model.last_verified_information_rules
+                converter = ConvertToRules(DMSRules)
+                converted_rules = converter.transform(info_rules).rules
+            elif target == "information":
+                source_id, dms_rules = self._state.data_model.last_verified_dms_rules
+                converter = ConvertToRules(InformationRules)
+                converted_rules = converter.transform(dms_rules).rules
+            else:
+                # Session errors are not caught by the catch_issues context manager
+                raise NeatSessionError(f"Target {target} not supported.")
+
         end = datetime.now(timezone.utc)
+        if issues:
+            self._state.data_model.issue_lists.append(issues)
 
-        # Provenance
-        change = Change.from_rules_activity(
-            converted_rules,
-            converter.agent,
-            start,
-            end,
-            f"Converted data model {source_id} to {converted_rules.id_}",
-            self._state.data_model.provenance.source_entity(source_id)
-            or self._state.data_model.provenance.target_entity(source_id),
-        )
+        if converted_rules is not None and converter is not None:
+            # Provenance
+            change = Change.from_rules_activity(
+                converted_rules,
+                converter.agent,
+                start,
+                end,
+                f"Converted data model {source_id} to {converted_rules.id_}",
+                self._state.data_model.provenance.source_entity(source_id)
+                or self._state.data_model.provenance.target_entity(source_id),
+            )
+
+            self._state.data_model.write(converted_rules, change)
 
-        self._state.data_model.write(converted_rules, change)
+            if self._verbose and not issues.has_errors:
+                print(f"Rules converted to {target}")
+        else:
+            print("Conversion failed.")
+        if issues:
+            print("You can inspect the issues with the .inspect.issues(...) method.")
+            if issues.has_error_type(RegexViolationError):
+                print("You can use .prepare. to try to fix the issues")
 
-        if self._verbose:
-            print(f"Rules converted to {target}")
+        return issues
 
     def infer(
         self,

{cognite_neat-0.97.0 → cognite_neat-0.97.2}/cognite/neat/_session/_inspect.py

@@ -173,8 +173,18 @@ class InspectUploadOutcome:
                             continue
                         lines.append(f"#### {key}")
                         if isinstance(value, list):
-                            for v in value:
-                                lines.append(f"  * {v}")
+                            total = len(value)
+                            for i, v in enumerate(value):
+                                if key in ["created", "updated", "changed"]:
+                                    if i < 50:
+                                        lines.append(f"  * {v}")
+                                    elif i == 50 and total > 50:
+                                        lines.append(f"  * ... {total-50} more")
+                                    elif i == 50 and total == 50:
+                                        lines.append(f"  * {v}")
+                                else:
+                                    lines.append(f"  * {v}")
+
                         else:
                             lines.append(f"  * {value}")
 

{cognite_neat-0.97.0 → cognite_neat-0.97.2}/cognite/neat/_session/_prepare.py

@@ -148,7 +148,8 @@ class DataModelPrepareAPI:
                     f"Prepared data model {data_model_id} to be enterprise data "
                     f"model on top of {rules.metadata.as_data_model_id()}"
                 ),
-                self._state.data_model.provenance.source_entity(source_id),
+                self._state.data_model.provenance.source_entity(source_id)
+                or self._state.data_model.provenance.target_entity(source_id),
             )
 
             self._state.data_model.write(output.rules, change)
@@ -202,7 +203,8 @@ class DataModelPrepareAPI:
                     f"Prepared data model {data_model_id} to be solution data model "
                     f"on top of {rules.metadata.as_data_model_id()}"
                 ),
-                self._state.data_model.provenance.source_entity(source_id),
+                self._state.data_model.provenance.source_entity(source_id)
+                or self._state.data_model.provenance.target_entity(source_id),
             )
 
             self._state.data_model.write(output.rules, change)

{cognite_neat-0.97.0 → cognite_neat-0.97.2}/cognite/neat/_session/_set.py

@@ -2,11 +2,12 @@ from datetime import datetime, timezone
 
 from cognite.client import data_modeling as dm
 
+from cognite.neat._constants import COGNITE_MODELS
 from cognite.neat._rules.transformers import SetIDDMSModel
 from cognite.neat._store._provenance import Change
 
 from ._state import SessionState
-from .exceptions import intercept_session_exceptions
+from .exceptions import NeatSessionError, intercept_session_exceptions
 
 
 @intercept_session_exceptions
@@ -20,6 +21,12 @@ class SetAPI:
         if res := self._state.data_model.last_verified_dms_rules:
             source_id, rules = res
 
+            if rules.metadata.as_data_model_id() in COGNITE_MODELS:
+                raise NeatSessionError(
+                    "Cannot change the data model ID of a Cognite Data Model in NeatSession"
+                    " due to temporarily issue with the reverse direct relation interpretation"
+                )
+
             start = datetime.now(timezone.utc)
             transformer = SetIDDMSModel(new_model_id)
             output = transformer.transform(rules)
@@ -27,15 +34,16 @@ class SetAPI:
 
             # Provenance
             change = Change.from_rules_activity(
-                output,
+                output.rules,
                 transformer.agent,
                 start,
                 end,
                 "Changed data model id",
-                self._state.data_model.provenance.source_entity(source_id),
+                self._state.data_model.provenance.source_entity(source_id)
+                or self._state.data_model.provenance.target_entity(source_id),
             )
 
-            self._state.data_model.write(output, change)
+            self._state.data_model.write(output.rules, change)
             if self._verbose:
                 print(f"Data model ID set to {new_model_id}")
         else:

{cognite_neat-0.97.0 → cognite_neat-0.97.2}/cognite/neat/_session/_show.py

@@ -293,6 +293,19 @@ class ShowInstanceAPI(ShowBaseAPI):
         self._state = state
 
     def __call__(self) -> Any:
+        if IN_PYODIDE:
+            raise NeatSessionError(
+                "Instances visualization not available if neat is run in PYODIDE as "
+                "PYODIDE dues not support oxigraph storage for NeatSession."
+                "Try running neat in regular Jupyter notebook and set [bold]NeatSession(storage='oxigraph')[/bold]."
+            )
+
+        if not self._state.instances.store_type == "oxigraph":
+            raise NeatSessionError(
+                "Visualization is only available for Oxigraph store. "
+                'Try setting [bold]NeatSession(storage="oxigraph")[/bold] enable Oxigraph store.'
+            )
+
         if not self._state.instances.store.graph:
             raise NeatSessionError("No instances available. Try using [bold].read[/bold] to load instances.")
 

{cognite_neat-0.97.0 → cognite_neat-0.97.2}/cognite/neat/_session/_to.py

@@ -2,12 +2,14 @@ from pathlib import Path
 from typing import Any, Literal, overload
 
 from cognite.client import CogniteClient
+from cognite.client.data_classes.data_modeling import SpaceApply
 
 from cognite.neat._graph import loaders
 from cognite.neat._issues import IssueList, catch_warnings
 from cognite.neat._rules import exporters
-from cognite.neat._session._wizard import space_wizard
-from cognite.neat._utils.upload import UploadResultCore
+from cognite.neat._rules._constants import PATTERNS
+from cognite.neat._rules._shared import VerifiedRules
+from cognite.neat._utils.upload import UploadResultCore, UploadResultList
 
 from ._state import SessionState
 from .exceptions import NeatSessionError, intercept_session_exceptions
@@ -23,9 +25,24 @@ class ToAPI:
     def excel(
         self,
         io: Any,
+        model: Literal["dms", "information", "logical", "physical"] | None,
     ) -> None:
+        """Export the verified data model to Excel.
+
+        Args:
+            io: The file path or file-like object to write the Excel file to.
+            model: The format of the data model to export. Defaults to None.
+        """
         exporter = exporters.ExcelExporter()
-        exporter.export_to_file(self._state.data_model.last_verified_rule[1], Path(io))
+        rules: VerifiedRules
+        if model == "information" or model == "logical":
+            rules = self._state.data_model.last_verified_information_rules[1]
+        elif model == "dms" or model == "physical":
+            rules = self._state.data_model.last_verified_dms_rules[1]
+        else:
+            rules = self._state.data_model.last_verified_rule[1]
+
+        exporter.export_to_file(rules, Path(io))
         return None
 
     @overload
@@ -50,19 +67,29 @@ class CDFToAPI:
         self._state = state
         self._verbose = verbose
 
-    def instances(self, space: str | None = None):
+    def instances(self, space: str | None = None) -> UploadResultList:
         if not self._client:
             raise NeatSessionError("No CDF client provided!")
 
+        space = space or f"{self._state.data_model.last_verified_dms_rules[1].metadata.space}_instances"
+
+        if space and space == self._state.data_model.last_verified_dms_rules[1].metadata.space:
+            raise NeatSessionError("Space for instances must be different from the data model space.")
+        elif not PATTERNS.space_compliance.match(str(space)):
+            raise NeatSessionError("Please provide a valid space name. {PATTERNS.space_compliance.pattern}")
+
+        if not self._client.data_modeling.spaces.retrieve(space):
+            self._client.data_modeling.spaces.apply(SpaceApply(space=space))
+
         loader = loaders.DMSLoader.from_rules(
             self._state.data_model.last_verified_dms_rules[1],
             self._state.instances.store,
-            space_wizard(space=space),
+            instance_space=space,
         )
         result = loader.load_into_cdf(self._client)
         self._state.instances.outcome.append(result)
-        print("You can inspect the details with the .inspect.instances.outcome(...) method.")
-        return loader.load_into_cdf(self._client)
+        print("You can inspect the details with the .inspect.outcome.instances(...) method.")
+        return result
 
     def data_model(
         self,