cognite-neat 0.109.1__py3-none-any.whl → 0.109.3__py3-none-any.whl

cognite/neat/_rules/transformers/_converters.py

@@ -1,9 +1,11 @@
 import re
+import urllib.parse
 import warnings
 from abc import ABC
 from collections import Counter, defaultdict
 from collections.abc import Collection, Mapping
 from datetime import date, datetime
+from functools import cached_property
 from typing import ClassVar, Literal, TypeVar, cast, overload
 
 from cognite.client.data_classes import data_modeling as dms
@@ -23,11 +25,12 @@ from cognite.neat._constants import (
 from cognite.neat._issues.errors import NeatValueError
 from cognite.neat._issues.warnings import NeatValueWarning
 from cognite.neat._issues.warnings._models import (
-    EnterpriseModelNotBuildOnTopOfCDMWarning,
     SolutionModelBuildOnTopOfCDMWarning,
 )
+from cognite.neat._rules._constants import PATTERNS, get_reserved_words
 from cognite.neat._rules._shared import (
     ReadInputRules,
+    ReadRules,
     VerifiedRules,
 )
 from cognite.neat._rules.analysis import DMSAnalysis
@@ -35,6 +38,7 @@ from cognite.neat._rules.importers import DMSImporter
 from cognite.neat._rules.models import (
     DMSInputRules,
     DMSRules,
+    InformationInputRules,
     InformationRules,
     SheetList,
     data_types,
@@ -56,9 +60,9 @@ from cognite.neat._rules.models.entities import (
     ViewEntity,
 )
 from cognite.neat._rules.models.information import InformationClass, InformationMetadata, InformationProperty
-from cognite.neat._utils.text import to_camel
+from cognite.neat._utils.text import NamingStandardization, to_camel
 
-from ._base import T_VerifiedIn, T_VerifiedOut, VerifiedRulesTransformer
+from ._base import RulesTransformer, T_VerifiedIn, T_VerifiedOut, VerifiedRulesTransformer
 from ._verification import VerifyDMSRules
 
 T_InputInRules = TypeVar("T_InputInRules", bound=ReadInputRules)
@@ -71,6 +75,105 @@ class ConversionTransformer(VerifiedRulesTransformer[T_VerifiedIn, T_VerifiedOut
     ...
 
 
+class ToInformationCompliantEntities(
+    RulesTransformer[ReadRules[InformationInputRules], ReadRules[InformationInputRules]]
+):
+    """Converts input rules to rules that is compliant with the Information Model.
+
+    This is typically used with importers from arbitrary sources to ensure that classes and properties have valid
+    names.
+
+    Args:
+        renaming: How to handle renaming of entities that are not compliant with the Information Model.
+            - "warning": Raises a warning and renames the entity.
+            - "skip": Renames the entity without raising a warning.
+    """
+
+    def __init__(self, renaming: Literal["warning", "skip"] = "skip") -> None:
+        self._renaming = renaming
+
+    @property
+    def description(self) -> str:
+        return "Ensures that all entities are compliant with the Information Model."
+
+    def transform(self, rules: ReadRules[InformationInputRules]) -> ReadRules[InformationInputRules]:
+        if rules.rules is None:
+            return rules
+        # Doing dump to obtain a copy, and ensure that all entities are created. Input allows
+        # string for entities, the dump call will convert these to entities.
+        dumped = rules.rules.dump()
+        copy = InformationInputRules.load(dumped)
+
+        new_by_old_class_suffix: dict[str, str] = {}
+        for cls in copy.classes:
+            cls_entity = cast(ClassEntity, cls.class_)  # Safe due to the dump above
+            if not PATTERNS.class_id_compliance.match(cls_entity.suffix):
+                new_suffix = self._fix_cls_suffix(cls_entity.suffix)
+                if self._renaming == "warning":
+                    warnings.warn(
+                        NeatValueWarning(f"Invalid class name {cls_entity.suffix!r}.Renaming to {new_suffix}"),
+                        stacklevel=2,
+                    )
+                cls.class_.suffix = new_suffix  # type: ignore[union-attr]
+
+        for cls_ in copy.classes:
+            if cls_.implements:
+                for i, parent in enumerate(cls_.implements):
+                    if isinstance(parent, ClassEntity) and parent.suffix in new_by_old_class_suffix:
+                        cls_.implements[i].suffix = new_by_old_class_suffix[parent.suffix]  # type: ignore[union-attr]
+
+        for prop in copy.properties:
+            if not PATTERNS.information_property_id_compliance.match(prop.property_):
+                new_property = self._fix_property(prop.property_)
+                if self._renaming == "warning":
+                    warnings.warn(
+                        NeatValueWarning(
+                            f"Invalid property name {prop.class_.suffix}.{prop.property_!r}. Renaming to {new_property}"  # type: ignore[union-attr]
+                        ),
+                        stacklevel=2,
+                    )
+                prop.property_ = new_property
+
+            if isinstance(prop.class_, ClassEntity) and prop.class_.suffix in new_by_old_class_suffix:
+                prop.class_.suffix = new_by_old_class_suffix[prop.class_.suffix]
+
+            if isinstance(prop.value_type, ClassEntity) and prop.value_type.suffix in new_by_old_class_suffix:
+                prop.value_type.suffix = new_by_old_class_suffix[prop.value_type.suffix]
+
+            if isinstance(prop.value_type, MultiValueTypeInfo):
+                for i, value_type in enumerate(prop.value_type.types):
+                    if isinstance(value_type, ClassEntity) and value_type.suffix in new_by_old_class_suffix:
+                        prop.value_type.types[i].suffix = new_by_old_class_suffix[value_type.suffix]  # type: ignore[union-attr]
+
+        return ReadRules(rules=copy, read_context=rules.read_context)
+
+    @cached_property
+    def _reserved_class_words(self) -> set[str]:
+        return set(get_reserved_words("class"))
+
+    @cached_property
+    def _reserved_property_words(self) -> set[str]:
+        return set(get_reserved_words("property"))
+
+    def _fix_cls_suffix(self, suffix: str) -> str:
+        if suffix in self._reserved_class_words:
+            return f"My{suffix}"
+        suffix = urllib.parse.unquote(suffix)
+        suffix = NamingStandardization.standardize_class_str(suffix)
+        if len(suffix) > 252:
+            suffix = suffix[:252]
+        return suffix
+
+    def _fix_property(self, property_: str) -> str:
+        if property_ in self._reserved_property_words:
+            return f"my{property_}"
+        property_ = urllib.parse.unquote(property_)
+        property_ = NamingStandardization.standardize_property_str(property_)
+        if len(property_) > 252:
+            property_ = property_[:252]
+        return property_
+
+
 class ToCompliantEntities(VerifiedRulesTransformer[InformationRules, InformationRules]):  # type: ignore[misc]
     """Converts input rules to rules with compliant entity IDs that match regex patters used
     by DMS schema components."""
@@ -246,6 +349,116 @@ class PrefixEntities(ConversionTransformer):  # type: ignore[type-var]
         return entity
 
 
+class StandardizeNaming(ConversionTransformer):
+    """Sets views/classes/container names to PascalCase and properties to camelCase."""
+
+    @property
+    def description(self) -> str:
+        return "Sets views/classes/containers names to PascalCase and properties to camelCase."
+
+    @overload
+    def transform(self, rules: DMSRules) -> DMSRules: ...
+
+    @overload
+    def transform(self, rules: InformationRules) -> InformationRules: ...
+
+    def transform(self, rules: InformationRules | DMSRules) -> InformationRules | DMSRules:
+        output = rules.model_copy(deep=True)
+        if isinstance(output, InformationRules):
+            return self._standardize_information_rules(output)
+        elif isinstance(output, DMSRules):
+            return self._standardize_dms_rules(output)
+        raise NeatValueError(f"Unsupported rules type: {type(output)}")
+
+    def _standardize_information_rules(self, rules: InformationRules) -> InformationRules:
+        new_by_old_class_suffix: dict[str, str] = {}
+        for cls in rules.classes:
+            new_suffix = NamingStandardization.standardize_class_str(cls.class_.suffix)
+            new_by_old_class_suffix[cls.class_.suffix] = new_suffix
+            cls.class_.suffix = new_suffix
+
+        for cls in rules.classes:
+            if cls.implements:
+                for i, parent in enumerate(cls.implements):
+                    if parent.suffix in new_by_old_class_suffix:
+                        cls.implements[i].suffix = new_by_old_class_suffix[parent.suffix]
+
+        for prop in rules.properties:
+            prop.property_ = NamingStandardization.standardize_property_str(prop.property_)
+            if prop.class_.suffix in new_by_old_class_suffix:
+                prop.class_.suffix = new_by_old_class_suffix[prop.class_.suffix]
+
+            if isinstance(prop.value_type, ClassEntity) and prop.value_type.suffix in new_by_old_class_suffix:
+                prop.value_type.suffix = new_by_old_class_suffix[prop.value_type.suffix]
+
+            if isinstance(prop.value_type, MultiValueTypeInfo):
+                for i, value_type in enumerate(prop.value_type.types):
+                    if isinstance(value_type, ClassEntity) and value_type.suffix in new_by_old_class_suffix:
+                        prop.value_type.types[i].suffix = new_by_old_class_suffix[value_type.suffix]  # type: ignore[union-attr]
+
+        return rules
+
+    def _standardize_dms_rules(self, rules: DMSRules) -> DMSRules:
+        new_by_old_view: dict[str, str] = {}
+        for view in rules.views:
+            new_suffix = NamingStandardization.standardize_class_str(view.view.suffix)
+            new_by_old_view[view.view.suffix] = new_suffix
+            view.view.suffix = new_suffix
+        new_by_old_container: dict[str, str] = {}
+        if rules.containers:
+            for container in rules.containers:
+                new_suffix = NamingStandardization.standardize_class_str(container.container.suffix)
+                new_by_old_container[container.container.suffix] = new_suffix
+                container.container.suffix = new_suffix
+
+        for view in rules.views:
+            if view.implements:
+                for i, parent in enumerate(view.implements):
+                    if parent.suffix in new_by_old_view:
+                        view.implements[i].suffix = new_by_old_view[parent.suffix]
+            if view.filter_ and isinstance(view.filter_, HasDataFilter) and view.filter_.inner:
+                for i, item in enumerate(view.filter_.inner):
+                    if isinstance(item, ContainerEntity) and item.suffix in new_by_old_container:
+                        view.filter_.inner[i].suffix = new_by_old_container[item.suffix]
+                    if isinstance(item, ViewEntity) and item.suffix in new_by_old_view:
+                        view.filter_.inner[i].suffix = new_by_old_view[item.suffix]
+        if rules.containers:
+            for container in rules.containers:
+                if container.constraint:
+                    for i, constraint in enumerate(container.constraint):
+                        if constraint.suffix in new_by_old_container:
+                            container.constraint[i].suffix = new_by_old_container[constraint.suffix]
+        new_property_by_view_by_old_property: dict[ViewEntity, dict[str, str]] = defaultdict(dict)
+        for prop in rules.properties:
+            if prop.view.suffix in new_by_old_view:
+                prop.view.suffix = new_by_old_view[prop.view.suffix]
+            new_view_property = NamingStandardization.standardize_property_str(prop.view_property)
+            new_property_by_view_by_old_property[prop.view][prop.view_property] = new_view_property
+            prop.view_property = new_view_property
+            if isinstance(prop.value_type, ViewEntity) and prop.value_type.suffix in new_by_old_view:
+                prop.value_type.suffix = new_by_old_view[prop.value_type.suffix]
+            if (
+                isinstance(prop.connection, EdgeEntity)
+                and prop.connection.properties
+                and prop.connection.properties.suffix in new_by_old_view
+            ):
+                prop.connection.properties.suffix = new_by_old_view[prop.connection.properties.suffix]
+            if isinstance(prop.container, ContainerEntity) and prop.container.suffix in new_by_old_container:
+                prop.container.suffix = new_by_old_container[prop.container.suffix]
+            if prop.container_property:
+                prop.container_property = NamingStandardization.standardize_property_str(prop.container_property)
+        for prop in rules.properties:
+            if (
+                isinstance(prop.connection, ReverseConnectionEntity)
+                and isinstance(prop.value_type, ViewEntity)
+                and prop.value_type in new_property_by_view_by_old_property
+            ):
+                new_by_old_property = new_property_by_view_by_old_property[prop.value_type]
+                if prop.connection.property_ in new_by_old_property:
+                    prop.connection.property_ = new_by_old_property[prop.connection.property_]
+        return rules
+
+
 class InformationToDMS(ConversionTransformer[InformationRules, DMSRules]):
     """Converts InformationRules to DMSRules."""
 
@@ -339,13 +552,6 @@ class ToEnterpriseModel(ToExtensionModel):
         self.move_connections = move_connections
 
     def transform(self, rules: DMSRules) -> DMSRules:
-        reference_model_id = rules.metadata.as_data_model_id()
-        if reference_model_id not in COGNITE_MODELS:
-            warnings.warn(
-                EnterpriseModelNotBuildOnTopOfCDMWarning(reference_model_id=reference_model_id).as_message(),
-                stacklevel=2,
-            )
-
         return self._to_enterprise(rules)
 
     def _to_enterprise(self, reference_model: DMSRules) -> DMSRules:
@@ -565,12 +771,10 @@ class ToSolutionModel(ToExtensionModel):
         renaming: dict[ViewEntity, ViewEntity] = {}
         new_views = SheetList[DMSView]()
         read_view_by_new_view: dict[ViewEntity, ViewEntity] = {}
-        skipped_views: set[ViewEntity] = set()
         for ref_view in reference.views:
             if (self.skip_cognite_views and ref_view.view.space in COGNITE_SPACES) or (
                 self.exclude_views_in_other_spaces and ref_view.view.space != reference.metadata.space
             ):
-                skipped_views.add(ref_view.view)
                 continue
             new_entity = ViewEntity(
                 # MyPy we validate that version is string in the constructor
@@ -603,15 +807,17 @@ class ToSolutionModel(ToExtensionModel):
             new_views.append(ref_view.model_copy(deep=True, update={"implements": None, "view": new_entity}))
 
         new_properties = SheetList[DMSProperty]()
+        new_view_entities = {view.view for view in new_views}
         for prop in reference.properties:
-            if prop.view in skipped_views:
-                continue
             new_property = prop.model_copy(deep=True)
             if new_property.value_type in renaming and isinstance(new_property.value_type, ViewEntity):
                 new_property.value_type = renaming[new_property.value_type]
             if new_property.view in renaming:
                 new_property.view = renaming[new_property.view]
-            new_properties.append(new_property)
+            if new_property.view in new_view_entities and (
+                not isinstance(new_property.value_type, ViewEntity) or new_property.value_type in new_view_entities
+            ):
+                new_properties.append(new_property)
         return new_views, new_properties, read_view_by_new_view
 
     def _create_containers_update_view_filter(

cognite/neat/_session/_base.py

@@ -16,6 +16,7 @@ from cognite.neat._rules.transformers import (
     InformationToDMS,
     MergeDMSRules,
     MergeInformationRules,
+    ToInformationCompliantEntities,
     VerifyInformationRules,
 )
 from cognite.neat._store._rules_store import RulesEntity
@@ -235,13 +236,19 @@ class NeatSession:
 
         def action() -> tuple[InformationRules, DMSRules | None]:
             unverified_information = importer.to_rules()
+            unverified_information = ToInformationCompliantEntities(renaming="warning").transform(
+                unverified_information
+            )
+
             extra_info = VerifyInformationRules().transform(unverified_information)
             if not last_entity:
                 return extra_info, None
             merged_info = MergeInformationRules(extra_info).transform(last_entity.information)
             if not last_entity.dms:
                 return merged_info, None
+
             extra_dms = InformationToDMS(reserved_properties="warning").transform(extra_info)
+
             merged_dms = MergeDMSRules(extra_dms).transform(last_entity.dms)
             return merged_info, merged_dms
 

cognite/neat/_session/_collector.py

@@ -65,7 +65,10 @@ class Collector:
         if kwargs:
             for key, value in kwargs.items():
                 event_information[key] = self._serialize_value(value)[:500]
-        self._track(command, event_information)
+
+        with suppress(RuntimeError):
+            # In case any thread issues, the tracking should not crash the program
+            self._track(command, event_information)
 
     @staticmethod
     def _serialize_value(value: Any) -> str:

cognite/neat/_session/_create.py

@@ -3,6 +3,7 @@ from typing import Literal
 from cognite.client.data_classes.data_modeling import DataModelIdentifier
 
 from cognite.neat._issues import IssueList
+from cognite.neat._rules.models import DMSRules, InformationRules
 from cognite.neat._rules.models.dms import DMSValidation
 from cognite.neat._rules.transformers import (
     IncludeReferenced,
@@ -38,22 +39,27 @@ class CreateAPI:
             org_name: Organization name to use for the views in the enterprise data model.
             dummy_property: The dummy property to use as placeholder for the views in the new data model.
 
+        What does this function do?
+            1. It creates a new view for each view in the current data model that implements the view it is based on.
+            2. If dummy_property is set, it will create a container with one property for each view and connect the
+               view to the container.
+            3. It will repeat all connection properties in the new views and update the ValueTypes to match the new
+               views.
+
         !!! note "Enterprise Data Model Creation"
 
             Always create an enterprise data model from a Cognite Data Model as this will
             assure all the Cognite Data Fusion applications to run smoothly, such as
                 - Search
                 - Atlas AI
-                - ...
-
-        !!! note "Move Connections"
-
-            If you want to move the connections to the new data model, set the move_connections
-            to True. This will move the connections to the new data model and use new model
-            views as the source and target views.
+                - Infield
+                - Canvas
+                - Maintain
+                - Charts
 
         """
-        return self._state.rule_transform(
+        last_rules = self._get_last_rules()
+        issues = self._state.rule_transform(
             ToEnterpriseModel(
                 new_model_id=data_model_id,
                 org_name=org_name,
@@ -61,6 +67,15 @@ class CreateAPI:
                 move_connections=True,
             )
         )
+        if last_rules and not issues.has_errors:
+            self._state.last_reference = last_rules
+        return issues
+
+    def _get_last_rules(self) -> InformationRules | DMSRules | None:
+        if not self._state.rule_store.provenance:
+            return None
+        last_entity = self._state.rule_store.provenance[-1].target_entity
+        return last_entity.dms or last_entity.information
 
     def solution_model(
         self,
@@ -76,6 +91,13 @@ class CreateAPI:
                 and the enterprise data model.
             view_prefix: The prefix to use for the views in the enterprise data model.
 
+        What does this function do?
+        1. It will create two new views for each view in the current data model. The first view will be read-only and
+           prefixed with the 'view_prefix'. The second view will be writable and have one property that connects to the
+           read-only view named 'direct_property'.
+        2. It will repeat all connection properties in the new views and update the ValueTypes to match the new views.
+        3. Each writable view will have a container with the single property that connects to the read-only view.
+
         !!! note "Solution Data Model Mode"
 
             The read-only solution model will only be able to read from the existing containers
@@ -88,7 +110,8 @@ class CreateAPI:
             the containers in the solution data model space.
 
         """
-        return self._state.rule_transform(
+        last_rules = self._get_last_rules()
+        issues = self._state.rule_transform(
             ToSolutionModel(
                 new_model_id=data_model_id,
                 properties="connection",
@@ -96,24 +119,32 @@ class CreateAPI:
                 view_prefix=view_prefix,
             )
         )
+        if last_rules and not issues.has_errors:
+            self._state.last_reference = last_rules
+        return issues
 
     def data_product_model(
         self,
         data_model_id: DataModelIdentifier,
         include: Literal["same-space", "all"] = "same-space",
-    ) -> None:
+    ) -> IssueList:
         """Uses the current data model as a basis to create data product data model.
 
         A data product model is a data model that ONLY maps to containers and do not use implements. This is
         typically used for defining the data in a data product.
 
+        What does this function do?
+        1. It creates a new view for each view in the current data model. The new views uses the same filter
+           as the view it is based on.
+        2. It will repeat all connection properties in the new views and update the ValueTypes to match the new views.
+
         Args:
             data_model_id: The data product data model id that is being created.
             include: The views to include in the data product data model. Can be either "same-space" or "all".
                 If you set same-space, only the properties of the views in the same space as the data model
                 will be included.
         """
-
+        last_rules = self._get_last_rules()
         view_ids, container_ids = DMSValidation(
             self._state.rule_store.last_verified_dms_rules
         ).imported_views_and_containers_ids()
@@ -130,4 +161,7 @@ class CreateAPI:
 
         transformers.append(ToDataProductModel(new_model_id=data_model_id, include=include))
 
-        self._state.rule_transform(*transformers)
+        issues = self._state.rule_transform(*transformers)
+        if last_rules and not issues.has_errors:
+            self._state.last_reference = last_rules
+        return issues

cognite/neat/_session/_prepare.py

@@ -3,6 +3,7 @@ from typing import Any
 
 from rdflib import URIRef
 
+from cognite.neat._alpha import AlphaFlags
 from cognite.neat._graph.transformers import (
     ConnectionToLiteral,
     ConvertLiteral,
@@ -12,9 +13,7 @@ from cognite.neat._graph.transformers import (
 from cognite.neat._graph.transformers._rdfpath import MakeConnectionOnExactMatch
 from cognite.neat._issues import IssueList
 from cognite.neat._issues.errors import NeatValueError
-from cognite.neat._rules.transformers import (
-    PrefixEntities,
-)
+from cognite.neat._rules.transformers import PrefixEntities, StandardizeNaming
 from cognite.neat._utils.text import humanize_collection
 
 from ._state import SessionState
@@ -264,3 +263,12 @@ class DataModelPrepareAPI:
         """
 
         return self._state.rule_transform(PrefixEntities(prefix))  # type: ignore[arg-type]
+
+    def standardize_naming(self) -> IssueList:
+        """Standardize the naming of all views/classes/properties in the data model.
+
+        For classes/views/containers, the naming will be standardized to PascalCase.
+        For properties, the naming will be standardized to camelCase.
+        """
+        AlphaFlags.standardize_naming.warn()
+        return self._state.rule_transform(StandardizeNaming())

cognite/neat/_session/_read.py

@@ -1,8 +1,10 @@
+import warnings
 from typing import Any, Literal, cast
 
 from cognite.client.data_classes.data_modeling import DataModelId, DataModelIdentifier
 from cognite.client.utils.useful_types import SequenceNotStr
 
+from cognite.neat._alpha import AlphaFlags
 from cognite.neat._client import NeatClient
 from cognite.neat._constants import (
     CLASSIC_CDF_NAMESPACE,
@@ -286,16 +288,26 @@ class ExcelReadAPI(BaseReadAPI):
         super().__init__(state, verbose)
         self.examples = ExcelExampleAPI(state, verbose)
 
-    def __call__(self, io: Any) -> IssueList:
+    def __call__(self, io: Any, enable_manual_edit: bool = False) -> IssueList:
         """Reads a Neat Excel Rules sheet to the graph store. The rules sheet may stem from an Information architect,
         or a DMS Architect.
 
         Args:
             io: file path to the Excel sheet
+            enable_manual_edit: If True, the user will be able to re-import rules which where edit outside NeatSession
+
+        !!! note "Manual Edit Warning"
+            This is an alpha feature and is subject to change without notice.
+            It is expected to have some limitations and may not work as expected in all cases.
         """
         reader = NeatReader.create(io)
         path = reader.materialize_path()
-        return self._state.rule_import(importers.ExcelImporter(path))
+
+        if enable_manual_edit:
+            warnings.filterwarnings("default")
+            AlphaFlags.manual_rules_edit.warn()
+
+        return self._state.rule_import(importers.ExcelImporter(path), enable_manual_edit)
 
 
 @session_class_wrapper

cognite/neat/_session/_state.py

@@ -40,8 +40,12 @@ class SessionState:
         self.instances.store.add_rules(last_entity.information)
         return issues
 
-    def rule_import(self, importer: BaseImporter) -> IssueList:
-        issues = self.rule_store.import_rules(importer, client=self.client)
+    def rule_import(self, importer: BaseImporter, enable_manual_edit: bool = False) -> IssueList:
+        issues = self.rule_store.import_rules(
+            importer,
+            client=self.client,
+            enable_manual_edit=enable_manual_edit,
+        )
         if self.rule_store.empty:
             result = "failed"
         else:
@@ -74,7 +78,7 @@ class InstancesState:
         self.outcome = UploadResultList()
 
         # Ensure that error handling is done in the constructor
-        self.store = _session_method_wrapper(self._create_store, "NeatSession")()
+        self.store: NeatGraphStore = _session_method_wrapper(self._create_store, "NeatSession")()
 
         if self.storage_path:
             print("Remember to close neat session .close() once you are done to avoid oxigraph lock.")

cognite/neat/_session/_to.py

@@ -6,6 +6,7 @@ from typing import Any, Literal, overload
 
 from cognite.client import data_modeling as dm
 
+from cognite.neat._alpha import AlphaFlags
 from cognite.neat._constants import COGNITE_MODELS
 from cognite.neat._graph import loaders
 from cognite.neat._rules import exporters
@@ -35,6 +36,8 @@ class ToAPI:
         self,
         io: Any,
         include_reference: bool = True,
+        include_properties: Literal["same-space", "all"] = "all",
+        add_empty_rows: bool = False,
     ) -> None:
         """Export the verified data model to Excel.
 
@@ -42,7 +45,10 @@ class ToAPI:
             io: The file path or file-like object to write the Excel file to.
             include_reference: If True, the reference data model will be included. Defaults to True.
                 Note that this only applies if you have created the data model using the
-                .to_enterprise(), .to_solution(), or .to_data_product() methods.
+                create.enterprise_model(...), create.solution_model(), or create.data_product_model() methods.
+            include_properties: The properties to include in the Excel file. Defaults to "all".
+                - "same-space": Only properties that are in the same space as the data model will be included.
+            add_empty_rows: If True, empty rows will be added between each component. Defaults to False.
 
         Example:
             Export information model to excel rules sheet
@@ -58,17 +64,17 @@ class ToAPI:
             neat = NeatSession(client)
 
             neat.read.cdf(("cdf_cdm", "CogniteCore", "v1"))
-            neat.verify()
-            neat.prepare.data_model.to_enterprise(
+            neat.create.enterprise_model(
                 data_model_id=("sp_doctrino_space", "ExtensionCore", "v1"),
                 org_name="MyOrg",
-                move_connections=True
             )
             dms_rules_file_name = "dms_rules.xlsx"
             neat.to.excel(dms_rules_file_name, include_reference=True)
             ```
         """
         reference_rules_with_prefix: tuple[VerifiedRules, str] | None = None
+        include_properties = include_properties.strip().lower()
+
         if include_reference and self._state.last_reference:
             if (
                 isinstance(self._state.last_reference.metadata, DMSMetadata)
@@ -79,7 +85,16 @@ class ToAPI:
                 prefix = "Ref"
             reference_rules_with_prefix = self._state.last_reference, prefix
 
-        exporter = exporters.ExcelExporter(styling="maximal", reference_rules_with_prefix=reference_rules_with_prefix)
+        if include_properties == "same-space":
+            warnings.filterwarnings("default")
+            AlphaFlags.same_space_properties_only_export.warn()
+
+        exporter = exporters.ExcelExporter(
+            styling="maximal",
+            reference_rules_with_prefix=reference_rules_with_prefix,
+            add_empty_rows=add_empty_rows,
+            include_properties=include_properties,  # type: ignore
+        )
         return self._state.rule_store.export_to_file(exporter, Path(io))
 
     def session(self, io: Any) -> None: