cognite-neat 0.99.0__py3-none-any.whl → 0.100.0__py3-none-any.whl

cognite/neat/_session/_base.py

@@ -10,11 +10,12 @@ 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, VerifiedRules
-from cognite.neat._rules.importers import DMSImporter
-from cognite.neat._rules.models import DMSInputRules, DMSRules, SheetList
+from cognite.neat._rules.models import DMSRules
+from cognite.neat._rules.models.dms import DMSValidation
+from cognite.neat._rules.models.information import InformationValidation
 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 import ConvertToRules, InformationToDMS, VerifyAnyRules
 from cognite.neat._rules.transformers._converters import ConversionTransformer
 from cognite.neat._store._provenance import (
     INSTANCES_ENTITY,
@@ -53,7 +54,7 @@ class NeatSession:
         self.show = ShowAPI(self._state)
         self.set = SetAPI(self._state, verbose)
         self.inspect = InspectAPI(self._state)
-        self.mapping = MappingAPI(self._state)
+        self.mapping = MappingAPI(self._state, self._client)
         self.drop = DropAPI(self._state)
         self.opt = OptAPI()
         self.opt._display()
@@ -66,64 +67,40 @@ class NeatSession:
 
     def verify(self) -> IssueList:
         source_id, last_unverified_rule = self._state.data_model.last_unverified_rule
-
-        reference_rules: DMSInputRules | None = None
-        if isinstance(last_unverified_rule.rules, DMSInputRules):
-            dms_rules = last_unverified_rule.rules
-            views_ids, containers_ids = dms_rules.imported_views_and_containers_ids()
-            if views_ids or containers_ids:
-                if self._client is None:
-                    raise NeatSessionError(
-                        "No client provided. You are referencing unknown views and containers in your data model, "
-                        "NEAT needs a client to lookup the definitions. "
-                        "Please set the client in the session, NeatSession(client=client)."
-                    )
-                schema = self._client.schema.retrieve(list(views_ids), list(containers_ids))
-
-                importer = DMSImporter(schema)
-                reference_rules = importer.to_rules().rules
-
-                if reference_rules is not None:
-                    dms_rules.views.extend(reference_rules.views)
-                    if dms_rules.containers:
-                        dms_rules.containers.extend(reference_rules.containers or [])
-
-        transformer = VerifyAnyRules("continue")
+        transformer = VerifyAnyRules("continue", validate=False)
         start = datetime.now(timezone.utc)
         output = transformer.try_transform(last_unverified_rule)
-        end = datetime.now(timezone.utc)
 
         if output.rules:
-            change = Change.from_rules_activity(
-                output.rules,
-                transformer.agent,
-                start,
-                end,
-                f"Verified data model {source_id} as {output.rules.metadata.identifier}",
-                self._state.data_model.provenance.source_entity(source_id)
-                or self._state.data_model.provenance.target_entity(source_id),
-            )
-            if reference_rules is not None and isinstance(output.rules, DMSRules):
-                # Remove the referenced views and containers from the rules
-                ref_view_ids = set(reference_rules.as_view_entities())
-                if ref_view_ids:
-                    output.rules.views = SheetList(
-                        [view for view in output.rules.views if view.view not in ref_view_ids]
-                    )
-                ref_container_ids = reference_rules.as_container_entities()
-                if output.rules.containers and ref_container_ids:
-                    output.rules.containers = SheetList(
-                        [
-                            container
-                            for container in output.rules.containers
-                            if container.container not in ref_container_ids
-                        ]
-                    )
-
-            self._state.data_model.write(output.rules, change)
-
-            if isinstance(output.rules, InformationRules):
-                self._state.instances.store.add_rules(output.rules)
+            if isinstance(output.rules, DMSRules):
+                issues = DMSValidation(output.rules, self._client).validate()
+            elif isinstance(output.rules, InformationRules):
+                issues = InformationValidation(output.rules).validate()
+            else:
+                raise NeatSessionError("Unsupported rule type")
+            if issues.has_errors:
+                # This is up for discussion, but I think we should not return rules that
+                # only pass the verification but not the validation.
+                output.rules = None
+            output.issues.extend(issues)
+
+            end = datetime.now(timezone.utc)
+
+            if output.rules:
+                change = Change.from_rules_activity(
+                    output.rules,
+                    transformer.agent,
+                    start,
+                    end,
+                    f"Verified data model {source_id} as {output.rules.metadata.identifier}",
+                    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)
+
+                if isinstance(output.rules, InformationRules):
+                    self._state.instances.store.add_rules(output.rules)
 
         output.issues.action = "verify"
         self._state.data_model.issue_lists.append(output.issues)
@@ -131,7 +108,16 @@ class NeatSession:
             print("You can inspect the issues with the .inspect.issues(...) method.")
         return output.issues
 
-    def convert(self, target: Literal["dms", "information"]) -> IssueList:
+    def convert(
+        self, target: Literal["dms", "information"], mode: Literal["edge_properties"] | None = None
+    ) -> IssueList:
+        """Converts the last verified data model to the target type.
+
+        Args:
+            target: The target type to convert the data model to.
+            mode: If the target is "dms", the mode to use for the conversion. None is used for default conversion.
+                "edge_properties" treas classes that implements Edge as edge properties.
+        """
         start = datetime.now(timezone.utc)
         issues = IssueList()
         converter: ConversionTransformer | None = None
@@ -139,7 +125,7 @@ class NeatSession:
         with catch_issues(issues):
             if target == "dms":
                 source_id, info_rules = self._state.data_model.last_verified_information_rules
-                converter = ConvertToRules(DMSRules)
+                converter = InformationToDMS(mode=mode)
                 converted_rules = converter.transform(info_rules).rules
             elif target == "information":
                 source_id, dms_rules = self._state.data_model.last_verified_dms_rules

cognite/neat/_session/_mapping.py

@@ -1,28 +1,50 @@
 from datetime import datetime, timezone
 
+from cognite.neat._client import NeatClient
+from cognite.neat._constants import DEFAULT_NAMESPACE
+from cognite.neat._rules.importers import DMSImporter
+from cognite.neat._rules.models.dms import DMSValidation
 from cognite.neat._rules.models.mapping import load_classic_to_core_mapping
-from cognite.neat._rules.transformers import RuleMapper
+from cognite.neat._rules.transformers import AsParentPropertyId, RuleMapper, VerifyDMSRules
+from cognite.neat._store._provenance import Agent as ProvenanceAgent
 from cognite.neat._store._provenance import Change
 
 from ._state import SessionState
-from .exceptions import session_class_wrapper
+from .exceptions import NeatSessionError, session_class_wrapper
 
 
 @session_class_wrapper
 class MappingAPI:
-    def __init__(self, state: SessionState):
+    def __init__(self, state: SessionState, client: NeatClient | None = None):
+        self.data_model = DataModelMappingAPI(state, client)
+
+
+@session_class_wrapper
+class DataModelMappingAPI:
+    def __init__(self, state: SessionState, client: NeatClient | None = None):
         self._state = state
+        self._client = client
 
-    def classic_to_core(self, org_name: str) -> None:
+    def classic_to_core(self, company_prefix: str, use_parent_property_name: bool = True) -> None:
         """Map classic types to core types.
 
         Note this automatically creates an extended CogniteCore model.
 
+        Args:
+            company_prefix: Prefix used for all extended CogniteCore types.
+            use_parent_property_name: Whether to use the parent property name in the extended CogniteCore model.
+                See below for more information.
+
+        If you extend CogniteAsset, with for example, ClassicAsset. You will map the property `parentId` to `parent`.
+        If you set `user_parent_property_name` to True, the `parentId` will be renamed to `parent` after the
+        mapping is done. If you set it to False, the property will remain `parentId`.
         """
         source_id, rules = self._state.data_model.last_verified_dms_rules
 
         start = datetime.now(timezone.utc)
-        transformer = RuleMapper(load_classic_to_core_mapping(org_name, rules.metadata.space, rules.metadata.version))
+        transformer = RuleMapper(
+            load_classic_to_core_mapping(company_prefix, rules.metadata.space, rules.metadata.version)
+        )
         output = transformer.transform(rules)
         end = datetime.now(timezone.utc)
 
@@ -37,3 +59,81 @@ class MappingAPI:
         )
 
         self._state.data_model.write(output.rules, change)
+
+        start = datetime.now(timezone.utc)
+
+        source_id, rules = self._state.data_model.last_verified_dms_rules
+        view_ids, container_ids = DMSValidation(rules, self._client).imported_views_and_containers_ids()
+        if not (view_ids or container_ids):
+            print(
+                f"Data model {rules.metadata.as_data_model_id()} does not have any referenced views or containers."
+                f"that is not already included in the data model."
+            )
+            return
+        if self._client is None:
+            raise NeatSessionError(
+                "No client provided. You are referencing unknown views and containers in your data model, "
+                "NEAT needs a client to lookup the definitions. "
+                "Please set the client in the session, NeatSession(client=client)."
+            )
+        schema = self._client.schema.retrieve([v.as_id() for v in view_ids], [c.as_id() for c in container_ids])
+        copy_ = rules.model_copy(deep=True)
+        copy_.metadata.version = f"{rules.metadata.version}_completed"
+        importer = DMSImporter(schema)
+        imported = importer.to_rules()
+        if imported.rules is None:
+            self._state.data_model.issue_lists.append(imported.issues)
+            raise NeatSessionError(
+                "Could not import the referenced views and containers. "
+                "See `neat.inspect.issues()` for more information."
+            )
+        verified = VerifyDMSRules("continue", validate=False).transform(imported.rules)
+        if verified.rules is None:
+            self._state.data_model.issue_lists.append(verified.issues)
+            raise NeatSessionError(
+                "Could not verify the referenced views and containers. "
+                "See `neat.inspect.issues()` for more information."
+            )
+        if copy_.containers is None:
+            copy_.containers = verified.rules.containers
+        else:
+            existing_containers = {c.container for c in copy_.containers}
+            copy_.containers.extend(
+                [c for c in verified.rules.containers or [] if c.container not in existing_containers]
+            )
+        existing_views = {v.view for v in copy_.views}
+        copy_.views.extend([v for v in verified.rules.views if v.view not in existing_views])
+        end = datetime.now(timezone.utc)
+
+        change = Change.from_rules_activity(
+            copy_,
+            ProvenanceAgent(id_=DEFAULT_NAMESPACE["agent/"]),
+            start,
+            end,
+            (f"Included referenced views and containers in the data model {rules.metadata.as_data_model_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(copy_, change)
+
+        if not use_parent_property_name:
+            return
+
+        source_id, rules = self._state.data_model.last_verified_dms_rules
+        start = datetime.now(timezone.utc)
+        transformer = AsParentPropertyId(self._client)
+        output = transformer.transform(rules)
+        end = datetime.now(timezone.utc)
+
+        change = Change.from_rules_activity(
+            output,
+            transformer.agent,
+            start,
+            end,
+            "Renaming property names to parent name",
+            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/_session/_prepare.py

@@ -8,11 +8,13 @@ from rdflib import URIRef
 
 from cognite.neat._client import NeatClient
 from cognite.neat._constants import DEFAULT_NAMESPACE
-from cognite.neat._graph.transformers import RelationshipToSchemaTransformer
+from cognite.neat._graph.transformers import RelationshipAsEdgeTransformer
 from cognite.neat._graph.transformers._rdfpath import MakeConnectionOnExactMatch
 from cognite.neat._rules._shared import InputRules, ReadRules
 from cognite.neat._rules.importers import DMSImporter
 from cognite.neat._rules.models import DMSRules
+from cognite.neat._rules.models.dms import DMSValidation
+from cognite.neat._rules.models.entities import ClassEntity
 from cognite.neat._rules.models.information._rules_input import InformationInputRules
 from cognite.neat._rules.transformers import (
     PrefixEntities,
@@ -112,20 +114,23 @@ class InstancePrepareAPI:
             raise NeatSessionError(f"Property {property_} is not defined for type {type_}. Cannot make connection")
         return type_uri[0], property_uri[0]
 
-    def relationships_as_connections(self, limit: int = 1) -> None:
+    def relationships_as_edges(self, min_relationship_types: int = 1, limit_per_type: int | None = None) -> None:
         """This assumes that you have read a classic CDF knowledge graph including relationships.
 
-        This transformer analyzes the relationships in the graph and modifies them to be part of the schema
-        for Assets, Events, Files, Sequences, and TimeSeries. Relationships without any properties
-        are replaced by a simple relationship between the source and target nodes. Relationships with
-        properties are replaced by a schema that contains the properties as attributes.
+        This method converts relationships into edges in the graph. This is useful as the
+        edges will be picked up as part of the schema connected to Assets, Events, Files, Sequences,
+        and TimeSeries in the InferenceImporter.
 
         Args:
-            limit: The minimum number of relationships that need to be present for it
-                to be converted into a schema. Default is 1.
+            min_relationship_types: The minimum number of relationship types that must exists to convert those
+                relationships to edges. For example, if there is only 5 relationships between Assets and TimeSeries,
+                and limit is 10, those relationships will not be converted to edges.
+            limit_per_type: The number of conversions to perform per relationship type. For example, if there are 10
+                relationships between Assets and TimeSeries, and limit_per_type is 1, only 1 of those relationships
+                will be converted to an edge. If None, all relationships will be converted.
 
         """
-        transformer = RelationshipToSchemaTransformer(limit=limit)
+        transformer = RelationshipAsEdgeTransformer(min_relationship_types, limit_per_type)
         self._state.instances.store.transform(transformer)
 
 
@@ -316,7 +321,7 @@ class DataModelPrepareAPI:
         source_id, rules = self._state.data_model.last_verified_dms_rules
 
         dms_ref: DMSRules | None = None
-        view_ids, container_ids = rules.imported_views_and_containers_ids(include_model_views_with_no_properties=True)
+        view_ids, container_ids = DMSValidation(rules, self._client).imported_views_and_containers_ids()
         if view_ids or container_ids:
             if self._client is None:
                 raise NeatSessionError(
@@ -324,7 +329,7 @@ class DataModelPrepareAPI:
                     "NEAT needs a client to lookup the definitions. "
                     "Please set the client in the session, NeatSession(client=client)."
                 )
-            schema = self._client.schema.retrieve(list(view_ids), list(container_ids))
+            schema = self._client.schema.retrieve([v.as_id() for v in view_ids], [c.as_id() for c in container_ids])
 
             importer = DMSImporter(schema)
             reference_rules = importer.to_rules().rules
@@ -409,7 +414,7 @@ class DataModelPrepareAPI:
         start = datetime.now(timezone.utc)
 
         source_id, rules = self._state.data_model.last_verified_dms_rules
-        view_ids, container_ids = rules.imported_views_and_containers_ids(include_model_views_with_no_properties=True)
+        view_ids, container_ids = DMSValidation(rules, self._client).imported_views_and_containers_ids()
         if not (view_ids or container_ids):
             print(
                 f"Data model {rules.metadata.as_data_model_id()} does not have any referenced views or containers."
@@ -422,7 +427,7 @@ class DataModelPrepareAPI:
                 "NEAT needs a client to lookup the definitions. "
                 "Please set the client in the session, NeatSession(client=client)."
             )
-        schema = self._client.schema.retrieve(list(view_ids), list(container_ids))
+        schema = self._client.schema.retrieve([v.as_id() for v in view_ids], [c.as_id() for c in container_ids])
         copy_ = rules.model_copy(deep=True)
         copy_.metadata.version = f"{rules.metadata.version}_completed"
         importer = DMSImporter(schema)
@@ -433,7 +438,7 @@ class DataModelPrepareAPI:
                 "Could not import the referenced views and containers. "
                 "See `neat.inspect.issues()` for more information."
             )
-        verified = VerifyDMSRules("continue", post_validate=False).transform(imported.rules)
+        verified = VerifyDMSRules("continue", validate=False).transform(imported.rules)
         if verified.rules is None:
             self._state.data_model.issue_lists.append(verified.issues)
             raise NeatSessionError(
@@ -462,3 +467,33 @@ class DataModelPrepareAPI:
         )
 
         self._state.data_model.write(copy_, change)
+
+    def add_implements_to_classes(self, suffix: Literal["Edge"], implements: str = "Edge") -> None:
+        """All classes with the suffix will have the implements property set to the given value.
+
+        Args:
+            suffix: The suffix of the classes to add the implements property to.
+            implements:  The value of the implements property to set.
+
+        """
+        source_id, rules = self._state.data_model.last_verified_information_rules
+        start = datetime.now(timezone.utc)
+
+        output = rules.model_copy(deep=True)
+        for class_ in output.classes:
+            if class_.class_.suffix.endswith(suffix):
+                class_.implements = [ClassEntity(prefix=class_.class_.prefix, suffix=implements)]
+        output.metadata.version = f"{rules.metadata.version}.implements_{implements}"
+        end = datetime.now(timezone.utc)
+
+        change = Change.from_rules_activity(
+            output,
+            ProvenanceAgent(id_=DEFAULT_NAMESPACE["agent/"]),
+            start,
+            end,
+            (f"Added implements property to classes with suffix {suffix}"),
+            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)

cognite/neat/_session/_read.py

@@ -20,7 +20,7 @@ from cognite.neat._store._provenance import Entity as ProvenanceEntity
 from cognite.neat._utils.reader import GitHubReader, NeatReader, PathReader
 
 from ._state import SessionState
-from ._wizard import NeatObjectType, RDFFileType, object_wizard, rdf_dm_wizard
+from ._wizard import NeatObjectType, RDFFileType, XMLFileType, object_wizard, rdf_dm_wizard, xml_format_wizard
 from .engine import import_engine
 from .exceptions import NeatSessionError, session_class_wrapper
 
@@ -35,6 +35,7 @@ class ReadAPI:
         self.excel = ExcelReadAPI(state, client, verbose)
         self.csv = CSVReadAPI(state, client, verbose)
         self.yaml = YamlReadAPI(state, client, verbose)
+        self.xml = XMLReadAPI(state, client, verbose)
 
 
 @session_class_wrapper
@@ -118,7 +119,7 @@ class CDFClassicAPI(BaseReadAPI):
             raise ValueError("No client provided. Please provide a client to read a data model.")
         return self._client
 
-    def graph(self, root_asset_external_id: str) -> None:
+    def graph(self, root_asset_external_id: str, limit_per_type: int | None = None) -> None:
         """Reads the classic knowledge graph from CDF.
 
         The Classic Graph consists of the following core resource type.
@@ -153,9 +154,12 @@ class CDFClassicAPI(BaseReadAPI):
 
         Args:
             root_asset_external_id: The external id of the root asset
+            limit_per_type: The maximum number of nodes to extract per core node type. If None, all nodes are extracted.
 
         """
-        extractor = extractors.ClassicGraphExtractor(self._get_client, root_asset_external_id=root_asset_external_id)
+        extractor = extractors.ClassicGraphExtractor(
+            self._get_client, root_asset_external_id=root_asset_external_id, limit_per_type=limit_per_type
+        )
 
         self._state.instances.store.write(extractor)
         if self._verbose:
@@ -248,7 +252,7 @@ class CSVReadAPI(BaseReadAPI):
         else:
             raise NeatValueError("Only file paths are supported for CSV files")
         engine = import_engine()
-        engine.set.source = ".csv"
+        engine.set.format = "csv"
         engine.set.file = path
         engine.set.type = type
         engine.set.primary_key = primary_key
@@ -257,6 +261,48 @@ class CSVReadAPI(BaseReadAPI):
         self._state.instances.store.write(extractor)
 
 
+@session_class_wrapper
+class XMLReadAPI(BaseReadAPI):
+    def __call__(
+        self,
+        io: Any,
+        format: XMLFileType | None = None,
+    ) -> None:
+        reader = NeatReader.create(io)
+        if isinstance(reader, GitHubReader):
+            path = Path(tempfile.gettempdir()).resolve() / reader.name
+            path.write_text(reader.read_text())
+        elif isinstance(reader, PathReader):
+            path = reader.path
+        else:
+            raise NeatValueError("Only file paths are supported for XML files")
+        if format is None:
+            format = xml_format_wizard()
+
+        if format.lower() == "dexpi":
+            return self.dexpi(path)
+
+        if format.lower() == "aml":
+            return self.aml(path)
+
+        else:
+            raise NeatValueError("Only support XML files of DEXPI format at the moment.")
+
+    def dexpi(self, path):
+        engine = import_engine()
+        engine.set.format = "dexpi"
+        engine.set.file = path
+        extractor = engine.create_extractor()
+        self._state.instances.store.write(extractor)
+
+    def aml(self, path):
+        engine = import_engine()
+        engine.set.format = "aml"
+        engine.set.file = path
+        extractor = engine.create_extractor()
+        self._state.instances.store.write(extractor)
+
+
 @session_class_wrapper
 class RDFReadAPI(BaseReadAPI):
     def __init__(self, state: SessionState, client: NeatClient | None, verbose: bool) -> None:

cognite/neat/_session/_set.py

@@ -29,6 +29,7 @@ class SetAPI:
 
             start = datetime.now(timezone.utc)
             transformer = SetIDDMSModel(new_model_id)
+
             output = transformer.transform(rules)
             end = datetime.now(timezone.utc)
 

cognite/neat/_session/_to.py

@@ -1,3 +1,4 @@
+from collections.abc import Collection
 from pathlib import Path
 from typing import Any, Literal, overload
 
@@ -9,6 +10,7 @@ from cognite.neat._issues import IssueList, catch_warnings
 from cognite.neat._rules import exporters
 from cognite.neat._rules._constants import PATTERNS
 from cognite.neat._rules._shared import VerifiedRules
+from cognite.neat._rules.exporters._rules2dms import Component
 from cognite.neat._utils.upload import UploadResultCore, UploadResultList
 
 from ._state import SessionState
@@ -51,7 +53,24 @@ class ToAPI:
     @overload
     def yaml(self, io: Any, format: Literal["neat", "toolkit"] = "neat") -> None: ...
 
-    def yaml(self, io: Any | None = None, format: Literal["neat", "toolkit"] = "neat") -> str | None:
+    def yaml(
+        self, io: Any | None = None, format: Literal["neat", "toolkit"] = "neat", skip_system_spaces: bool = True
+    ) -> str | None:
+        """Export the verified data model to YAML.
+
+        Args:
+            io: The file path or file-like object to write the YAML file to. Defaults to None.
+            format: The format of the YAML file. Defaults to "neat".
+            skip_system_spaces: If True, system spaces will be skipped. Defaults to True.
+
+        ... note::
+
+            - "neat": This is the format Neat uses to store the data model.
+            - "toolkit": This is the format used by Cognite Toolkit, that matches the CDF API.
+
+        Returns:
+            str | None: If io is None, the YAML string will be returned. Otherwise, None will be returned.
+        """
         if format == "neat":
             exporter = exporters.YAMLExporter()
             last_verified = self._state.data_model.last_verified_rule[1]
@@ -66,9 +85,12 @@ class ToAPI:
                     "This is required for the 'toolkit' format."
                 )
             dms_rule = self._state.data_model.last_verified_dms_rules[1]
-            exporters.DMSExporter().export_to_file(dms_rule, Path(io))
+            user_path = Path(io)
+            if user_path.suffix == "" and not user_path.exists():
+                user_path.mkdir(parents=True)
+            exporters.DMSExporter(remove_cdf_spaces=skip_system_spaces).export_to_file(dms_rule, user_path)
         else:
-            raise NeatSessionError("Please provide a valid format. {['neat', 'toolkit']}")
+            raise NeatSessionError("Please provide a valid format. 'neat' or 'toolkit'")
 
         return None
 
@@ -106,36 +128,40 @@ class CDFToAPI:
 
     def data_model(
         self,
-        existing_handling: Literal["fail", "skip", "update", "force"] = "skip",
+        existing: Literal["fail", "skip", "update", "force", "recreate"] = "update",
         dry_run: bool = False,
-        fallback_one_by_one: bool = False,
+        drop_data: bool = False,
+        components: Component | Collection[Component] | None = None,
     ):
         """Export the verified DMS data model to CDF.
 
         Args:
-            existing_handling: How to handle if component of data model exists. Defaults to "skip".
+            existing: What to do if the component already exists. Defaults to "update".
+                See the note below for more information about the options.
             dry_run: If True, no changes will be made to CDF. Defaults to False.
-            fallback_one_by_one: If True, will fall back to one-by-one upload if batch upload fails. Defaults to False.
+            drop_data: If existing is 'force' or 'recreate' and the operation will lead to data loss,
+                the component will be skipped unless drop_data is True. Defaults to False.
+                Note this only applies to spaces and containers if they contain data.
+            components: The components to export. If None, all components will be exported. Defaults to None.
 
         ... note::
 
         - "fail": If any component already exists, the export will fail.
         - "skip": If any component already exists, it will be skipped.
         - "update": If any component already exists, it will be updated.
-        - "force": If any component already exists, it will be deleted and recreated.
+        - "force": If any component already exists, and the update fails, it will be deleted and recreated.
+        - "recreate": All components will be deleted and recreated.
 
         """
 
-        exporter = exporters.DMSExporter(existing_handling=existing_handling)
+        exporter = exporters.DMSExporter(existing=existing, export_components=components, drop_data=drop_data)
 
         if not self._client:
             raise NeatSessionError("No client provided!")
 
         conversion_issues = IssueList(action="to.cdf.data_model")
         with catch_warnings(conversion_issues):
-            result = exporter.export_to_cdf(
-                self._state.data_model.last_verified_dms_rules[1], self._client, dry_run, fallback_one_by_one
-            )
+            result = exporter.export_to_cdf(self._state.data_model.last_verified_dms_rules[1], self._client, dry_run)
         result.insert(0, UploadResultCore(name="schema", issues=conversion_issues))
         self._state.data_model.outcome.append(result)
         print("You can inspect the details with the .inspect.data_model.outcome(...) method.")

cognite/neat/_session/_wizard.py

@@ -7,12 +7,17 @@ from cognite.neat._rules._constants import PATTERNS
 
 RDFFileType = Literal["Ontology", "IMF Types", "Inference"]
 NeatObjectType = Literal["Data Model", "Instances"]
+XMLFileType = Literal["dexpi", "aml"]
 
 
 def object_wizard(message: str = "Select object") -> NeatObjectType:
     return _selection(message, get_args(NeatObjectType))
 
 
+def xml_format_wizard(message: str = "Select XML format") -> XMLFileType:
+    return _selection(message, get_args(XMLFileType))
+
+
 def rdf_dm_wizard(message: str = "Select source:") -> RDFFileType:
     return _selection(message, get_args(RDFFileType))
 

cognite/neat/_session/engine/_interface.py

@@ -9,14 +9,15 @@ class Extractor(Protocol):
 
 
 class ConfigAPI(Protocol):
-    source: str | None
+    format: str | None = None
     file: Any | None
     type: str | None
     primary_key: str | None
+    mapping: Any | None = None
 
 
 class NeatEngine(Protocol):
-    version: str = "1.0.0"
+    version: str = "2.0.0"
 
     @property
     def set(self) -> ConfigAPI: ...