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

cognite/neat/_rules/transformers/_converters.py

@@ -4,7 +4,7 @@ from abc import ABC, abstractmethod
 from collections import Counter, defaultdict
 from collections.abc import Collection, Mapping
 from datetime import date, datetime
-from typing import Literal, TypeVar, cast
+from typing import Literal, TypeVar, cast, overload
 
 from cognite.client.data_classes import data_modeling as dms
 from cognite.client.data_classes.data_modeling import DataModelId, DataModelIdentifier, ViewId
@@ -42,8 +42,10 @@ from cognite.neat._rules.models.entities import (
     ContainerEntity,
     DMSUnknownEntity,
     EdgeEntity,
+    Entity,
     MultiValueTypeInfo,
     ReverseConnectionEntity,
+    T_Entity,
     UnknownEntity,
     ViewEntity,
 )
@@ -176,6 +178,74 @@ class ToCompliantEntities(RulesTransformer[InformationInputRules, InformationInp
         return fixed_definitions
 
 
+class PrefixEntities(RulesTransformer[InputRules, InputRules]):  # type: ignore[misc]
+    """Prefixes all entities with a given prefix."""
+
+    def __init__(self, prefix: str) -> None:
+        self._prefix = prefix
+
+    def transform(self, rules: InputRules | OutRules[InputRules]) -> ReadRules[InputRules]:
+        return ReadRules(self._transform(self._to_rules(rules)), IssueList(), {})
+
+    def _transform(self, rules: InputRules) -> InputRules:
+        rules.metadata.version += f"_prefixed_{self._prefix}"
+
+        if isinstance(rules, InformationInputRules):
+            # Todo Make Not mutate input class
+            prefixed_by_class: dict[str, str] = {}
+            for cls in rules.classes:
+                prefixed = str(self._with_prefix(cls.class_))
+                prefixed_by_class[str(cls.class_)] = prefixed
+                cls.class_ = prefixed
+            for prop in rules.properties:
+                prop.class_ = self._with_prefix(prop.class_)
+                if str(prop.value_type) in prefixed_by_class:
+                    prop.value_type = prefixed_by_class[str(prop.value_type)]
+            return rules
+        elif isinstance(rules, DMSInputRules):
+            # Todo not mutate input class new_dms = copy.deepcopy(rules)
+            prefixed_by_view: dict[str, str] = {}
+            for view in rules.views:
+                prefixed = str(self._with_prefix(view.view))
+                prefixed_by_view[str(view.view)] = prefixed
+                view.view = prefixed
+            for dms_prop in rules.properties:
+                dms_prop.view = self._with_prefix(dms_prop.view)
+                if str(dms_prop.value_type) in prefixed_by_view:
+                    dms_prop.value_type = prefixed_by_view[str(dms_prop.value_type)]
+            if rules.containers:
+                for container in rules.containers:
+                    container.container = self._with_prefix(container.container)
+            return rules
+        raise NeatValueError(f"Unsupported rules type: {type(rules)}")
+
+    @overload
+    def _with_prefix(self, raw: str) -> str: ...
+
+    @overload
+    def _with_prefix(self, raw: T_Entity) -> T_Entity: ...
+
+    def _with_prefix(self, raw: str | T_Entity) -> str | T_Entity:
+        is_entity_format = not isinstance(raw, str)
+        entity = Entity.load(raw)
+        output: ClassEntity | ViewEntity | ContainerEntity
+        if isinstance(entity, ClassEntity):
+            output = ClassEntity(prefix=entity.prefix, suffix=f"{self._prefix}{entity.suffix}", version=entity.version)
+        elif isinstance(entity, ViewEntity):
+            output = ViewEntity(
+                space=entity.space, externalId=f"{self._prefix}{entity.external_id}", version=entity.version
+            )
+        elif isinstance(entity, ContainerEntity):
+            output = ContainerEntity(space=entity.space, externalId=f"{self._prefix}{entity.external_id}")
+        elif isinstance(entity, UnknownEntity | Entity):
+            return f"{self._prefix}{raw}"
+        else:
+            raise NeatValueError(f"Unsupported entity type: {type(entity)}")
+        if is_entity_format:
+            return cast(T_Entity, output)
+        return str(output)
+
+
 class InformationToDMS(ConversionTransformer[InformationRules, DMSRules]):
     """Converts InformationRules to DMSRules."""
 
@@ -233,10 +303,11 @@ class ToExtension(RulesTransformer[DMSRules, DMSRules]):
         self,
         new_model_id: DataModelIdentifier,
         org_name: str = "My",
-        type_: Literal["enterprise", "solution"] = "enterprise",
+        type_: Literal["enterprise", "solution", "data_product"] = "enterprise",
         mode: Literal["read", "write"] = "read",
         dummy_property: str = "GUID",
         move_connections: bool = False,
+        include: Literal["same-space", "all"] = "same-space",
     ):
         self.new_model_id = DataModelId.load(new_model_id)
         if not self.new_model_id.version:
@@ -247,6 +318,7 @@ class ToExtension(RulesTransformer[DMSRules, DMSRules]):
         self.type_ = type_
         self.dummy_property = dummy_property
         self.move_connections = move_connections
+        self.include = include
 
     def transform(self, rules: DMSRules | OutRules[DMSRules]) -> JustRules[DMSRules]:
         # Copy to ensure immutability
@@ -274,6 +346,16 @@ class ToExtension(RulesTransformer[DMSRules, DMSRules]):
                 )
 
             return self._to_enterprise(reference_model)
+        elif self.type_ == "data_product":
+            expanded = self._expand_properties(reference_model.model_copy(deep=True))
+            if self.include == "same-space":
+                expanded.properties = SheetList[DMSProperty](
+                    [prop for prop in expanded.properties if prop.view.space == expanded.metadata.space]
+                )
+                expanded.views = SheetList[DMSView](
+                    [view for view in expanded.views if view.view.space == expanded.metadata.space]
+                )
+            return self._to_solution(expanded, remove_views_in_other_space=False)
 
         else:
             raise NeatValueError(f"Unsupported data model type: {self.type_}")
@@ -281,7 +363,7 @@ class ToExtension(RulesTransformer[DMSRules, DMSRules]):
     def _has_views_in_multiple_space(self, rules: DMSRules) -> bool:
         return any(view.view.space != rules.metadata.space for view in rules.views)
 
-    def _to_solution(self, reference_rules: DMSRules) -> JustRules[DMSRules]:
+    def _to_solution(self, reference_rules: DMSRules, remove_views_in_other_space: bool = True) -> JustRules[DMSRules]:
         """For creation of solution data model / rules specifically for mapping over existing containers."""
 
         dump = reference_rules.dump()
@@ -292,16 +374,11 @@ class ToExtension(RulesTransformer[DMSRules, DMSRules]):
         dump["metadata"]["external_id"] = self.new_model_id.external_id
         dump["metadata"]["version"] = self.new_model_id.version
 
-        # dropping reference and last from the dump as they can cause validation
-        # issues especially if reference is enterprise model build on top of CDM
-        dump.pop("reference", None)
-        dump.pop("last", None)
-
         # Set implement to NONE for all views
         for view in dump["views"]:
             view["implements"] = None
 
-        if self._has_views_in_multiple_space(reference_rules):
+        if remove_views_in_other_space and self._has_views_in_multiple_space(reference_rules):
             views_to_remove = []
             for view in dump["views"]:
                 if ":" in view["view"]:
@@ -312,7 +389,7 @@ class ToExtension(RulesTransformer[DMSRules, DMSRules]):
         solution_model = DMSRules.model_validate(DMSInputRules.load(dump).dump())
 
         # Dropping containers coming from reference model
-        solution_model.containers = SheetList[DMSContainer]()
+        solution_model.containers = None
 
         # We want to map properties to existing containers allowing extension
         for prop in solution_model.properties:
@@ -338,7 +415,7 @@ class ToExtension(RulesTransformer[DMSRules, DMSRules]):
 
             # Here we add ONLY dummy properties of the solution model and
             # corresponding solution model space containers to hold them
-            solution_model.containers.extend(new_containers)
+            solution_model.containers = new_containers
             solution_model.properties.extend(new_properties)
 
         return JustRules(solution_model)
@@ -377,6 +454,28 @@ class ToExtension(RulesTransformer[DMSRules, DMSRules]):
 
         return JustRules(enterprise_model)
 
+    @staticmethod
+    def _expand_properties(rules: DMSRules) -> DMSRules:
+        probe = DMSAnalysis(rules)
+        ancestor_properties_by_view = probe.classes_with_properties(
+            consider_inheritance=True, allow_different_namespace=True
+        )
+        property_ids_by_view = {
+            view: {prop.view_property for prop in properties}
+            for view, properties in probe.classes_with_properties(consider_inheritance=False).items()
+        }
+        for view, property_ids in property_ids_by_view.items():
+            ancestor_properties = ancestor_properties_by_view.get(view, [])
+            for prop in ancestor_properties:
+                if isinstance(prop.connection, ReverseConnectionEntity):
+                    # If you try to add a reverse direct relation of a parent, it will fail as the ValueType of the
+                    # original property will point to the parent view, and not the child.
+                    continue
+                if prop.view_property not in property_ids:
+                    rules.properties.append(prop)
+                    property_ids.add(prop.view_property)
+        return rules
+
     def _remove_cognite_affix(self, entity: _T_Entity) -> _T_Entity:
         """This method removes `Cognite` affix from the entity."""
         new_suffix = entity.suffix.replace("Cognite", self.org_name or "")

cognite/neat/_rules/transformers/_mapping.py

@@ -1,13 +1,16 @@
+import warnings
 from abc import ABC
 from collections import defaultdict
+from functools import cached_property
+from typing import Any, ClassVar, Literal
 
+from cognite.neat._issues.errors import NeatValueError
+from cognite.neat._issues.warnings import NeatValueWarning, PropertyOverwritingWarning
 from cognite.neat._rules._shared import JustRules, OutRules
-from cognite.neat._rules.models import DMSRules, InformationRules
-from cognite.neat._rules.models._base_rules import ClassRef
-from cognite.neat._rules.models.dms import DMSProperty
-from cognite.neat._rules.models.entities import ClassEntity
-from cognite.neat._rules.models.information import InformationClass
-from cognite.neat._rules.models.mapping import RuleMapping
+from cognite.neat._rules.models import DMSRules, SheetList
+from cognite.neat._rules.models.data_types import Enum
+from cognite.neat._rules.models.dms import DMSEnum, DMSProperty, DMSView
+from cognite.neat._rules.models.entities import ViewEntity
 
 from ._base import RulesTransformer
 
@@ -96,7 +99,7 @@ class MapOneToOne(MapOntoTransformers):
         return JustRules(solution)
 
 
-class RuleMapper(RulesTransformer[InformationRules, InformationRules]):
+class RuleMapper(RulesTransformer[DMSRules, DMSRules]):
     """Maps properties and classes using the given mapping.
 
     **Note**: This transformer mutates the input rules.
@@ -106,30 +109,102 @@ class RuleMapper(RulesTransformer[InformationRules, InformationRules]):
 
     """
 
-    def __init__(self, mapping: RuleMapping) -> None:
+    _mapping_fields: ClassVar[frozenset[str]] = frozenset(
+        ["connection", "value_type", "nullable", "immutable", "is_list", "default", "index", "constraint"]
+    )
+
+    def __init__(self, mapping: DMSRules, data_type_conflict: Literal["overwrite"] = "overwrite") -> None:
         self.mapping = mapping
+        self.data_type_conflict = data_type_conflict
+
+    @cached_property
+    def _view_by_entity_id(self) -> dict[str, DMSView]:
+        return {view.view.external_id: view for view in self.mapping.views}
 
-    def transform(self, rules: InformationRules | OutRules[InformationRules]) -> JustRules[InformationRules]:
+    @cached_property
+    def _property_by_view_property(self) -> dict[tuple[str, str], DMSProperty]:
+        return {(prop.view.external_id, prop.view_property): prop for prop in self.mapping.properties}
+
+    def transform(self, rules: DMSRules | OutRules[DMSRules]) -> JustRules[DMSRules]:
+        if self.data_type_conflict != "overwrite":
+            raise NeatValueError(f"Invalid data_type_conflict: {self.data_type_conflict}")
         input_rules = self._to_rules(rules)
+        new_rules = input_rules.model_copy(deep=True)
+        new_rules.metadata.version += "_mapped"
 
-        destination_by_source = self.mapping.properties.as_destination_by_source()
-        destination_cls_by_source = self.mapping.classes.as_destination_by_source()
-        used_destination_classes: set[ClassEntity] = set()
-        for prop in input_rules.properties:
-            if destination_prop := destination_by_source.get(prop.as_reference()):
-                prop.class_ = destination_prop.class_
-                prop.property_ = destination_prop.property_
-                used_destination_classes.add(destination_prop.class_)
-            elif destination_cls := destination_cls_by_source.get(ClassRef(Class=prop.class_)):
-                # If the property is not in the mapping, but the class is,
-                # then we should map the class to the destination
-                prop.class_ = destination_cls.class_
-
-        for cls_ in input_rules.classes:
-            if destination_cls := destination_cls_by_source.get(cls_.as_reference()):
-                cls_.class_ = destination_cls.class_
-        existing_classes = {cls_.class_ for cls_ in input_rules.classes}
-        for new_cls in used_destination_classes - existing_classes:
-            input_rules.classes.append(InformationClass(class_=new_cls))
-
-        return JustRules(input_rules)
+        for view in new_rules.views:
+            if mapping_view := self._view_by_entity_id.get(view.view.external_id):
+                view.implements = mapping_view.implements
+
+        for prop in new_rules.properties:
+            key = (prop.view.external_id, prop.view_property)
+            if key not in self._property_by_view_property:
+                continue
+            mapping_prop = self._property_by_view_property[key]
+            to_overwrite, conflicts = self._find_overwrites(prop, mapping_prop)
+            if conflicts and self.data_type_conflict == "overwrite":
+                warnings.warn(
+                    PropertyOverwritingWarning(prop.view.as_id(), "view", prop.view_property, tuple(conflicts)),
+                    stacklevel=2,
+                )
+            elif conflicts:
+                raise NeatValueError(f"Conflicting properties for {prop.view}.{prop.view_property}: {conflicts}")
+            for field_name, value in to_overwrite.items():
+                setattr(prop, field_name, value)
+            prop.container = mapping_prop.container
+            prop.container_property = mapping_prop.container_property
+
+        # Add missing views used as value types
+        existing_views = {view.view for view in new_rules.views}
+        new_value_types = {
+            prop.value_type
+            for prop in new_rules.properties
+            if isinstance(prop.value_type, ViewEntity) and prop.value_type not in existing_views
+        }
+        for new_value_type in new_value_types:
+            if mapping_view := self._view_by_entity_id.get(new_value_type.external_id):
+                new_rules.views.append(mapping_view)
+            else:
+                warnings.warn(NeatValueWarning(f"View {new_value_type} not found in mapping"), stacklevel=2)
+
+        # Add missing enums
+        existing_enum_collections = {item.collection for item in new_rules.enum or []}
+        new_enums = {
+            prop.value_type.collection
+            for prop in new_rules.properties
+            if isinstance(prop.value_type, Enum) and prop.value_type.collection not in existing_enum_collections
+        }
+        if new_enums:
+            new_rules.enum = new_rules.enum or SheetList[DMSEnum]([])
+            for item in self.mapping.enum or []:
+                if item.collection in new_enums:
+                    new_rules.enum.append(item)
+
+        return JustRules(new_rules)
+
+    def _find_overwrites(self, prop: DMSProperty, mapping_prop: DMSProperty) -> tuple[dict[str, Any], list[str]]:
+        """Finds the properties that need to be overwritten and returns them.
+
+        In addition, conflicting properties are returned. Note that overwriting properties that are
+        originally None is not considered a conflict. Thus, you can have properties to overwrite but no
+        conflicts.
+
+        Args:
+            prop: The property to compare.
+            mapping_prop: The property to compare against.
+
+        Returns:
+            A tuple with the properties to overwrite and the conflicting properties.
+
+        """
+        to_overwrite: dict[str, Any] = {}
+        conflicts: list[str] = []
+        for field_name in self._mapping_fields:
+            mapping_value = getattr(mapping_prop, field_name)
+            source_value = getattr(prop, field_name)
+            if mapping_value != source_value:
+                to_overwrite[field_name] = mapping_value
+                if source_value is not None:
+                    # These are used for warnings so we use the alias to make it more readable for the user
+                    conflicts.append(mapping_prop.model_fields[field_name].alias or field_name)
+        return to_overwrite, conflicts

cognite/neat/_rules/transformers/_verification.py

@@ -27,8 +27,9 @@ class VerificationTransformer(RulesTransformer[T_InputRules, T_VerifiedRules], A
 
     _rules_cls: type[T_VerifiedRules]
 
-    def __init__(self, errors: Literal["raise", "continue"]) -> None:
+    def __init__(self, errors: Literal["raise", "continue"], post_validate: bool = True) -> None:
         self.errors = errors
+        self.post_validate = post_validate
 
     def transform(self, rules: T_InputRules | OutRules[T_InputRules]) -> MaybeRules[T_VerifiedRules]:
         issues = IssueList()
@@ -39,7 +40,9 @@ class VerificationTransformer(RulesTransformer[T_InputRules, T_VerifiedRules], A
         verified_rules: T_VerifiedRules | None = None
         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]
+            dumped = in_.dump()
+            dumped["post_validate"] = self.post_validate
+            verified_rules = rules_cls.model_validate(dumped)  # type: ignore[assignment]
 
         if (future.result == "failure" or issues.has_errors or verified_rules is None) and self.errors == "raise":
             raise issues.as_errors()

cognite/neat/_session/_base.py

@@ -5,11 +5,13 @@ from cognite.client import CogniteClient
 from cognite.client import data_modeling as dm
 
 from cognite.neat import _version
+from cognite.neat._client import NeatClient
 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.models import DMSRules
+from cognite.neat._rules.importers import DMSImporter
+from cognite.neat._rules.models import DMSInputRules, DMSRules, SheetList
 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
@@ -18,10 +20,11 @@ from cognite.neat._store._provenance import (
     INSTANCES_ENTITY,
     Change,
 )
-from cognite.neat._utils.auth import _CLIENT_NAME
 
 from ._collector import _COLLECTOR, Collector
+from ._drop import DropAPI
 from ._inspect import InspectAPI
+from ._mapping import MappingAPI
 from ._prepare import PrepareAPI
 from ._read import ReadAPI
 from ._set import SetAPI
@@ -41,19 +44,19 @@ class NeatSession:
         verbose: bool = True,
         load_engine: Literal["newest", "cache", "skip"] = "cache",
     ) -> None:
-        self._client = client
+        self._client = NeatClient(client) if client else None
         self._verbose = verbose
         self._state = SessionState(store_type=storage)
-        self.read = ReadAPI(self._state, client, verbose)
-        self.to = ToAPI(self._state, client, verbose)
-        self.prepare = PrepareAPI(self._state, verbose)
+        self.read = ReadAPI(self._state, self._client, verbose)
+        self.to = ToAPI(self._state, self._client, verbose)
+        self.prepare = PrepareAPI(self._client, self._state, verbose)
         self.show = ShowAPI(self._state)
         self.set = SetAPI(self._state, verbose)
         self.inspect = InspectAPI(self._state)
+        self.mapping = MappingAPI(self._state)
+        self.drop = DropAPI(self._state)
         self.opt = OptAPI()
         self.opt._display()
-        if self._client is not None and self._client._config is not None:
-            self._client._config.client_name = _CLIENT_NAME
         if load_engine != "skip" and (engine_version := load_neat_engine(client, load_engine)):
             print(f"Neat Engine {engine_version} loaded.")
 
@@ -63,6 +66,28 @@ 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")
         start = datetime.now(timezone.utc)
         output = transformer.try_transform(last_unverified_rule)
@@ -78,6 +103,22 @@ class NeatSession:
                 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)
 

cognite/neat/_session/_drop.py

@@ -0,0 +1,35 @@
+from rdflib import URIRef
+
+from ._state import SessionState
+from .exceptions import session_class_wrapper
+
+try:
+    from rich import print
+except ImportError:
+    ...
+
+
+@session_class_wrapper
+class DropAPI:
+    def __init__(self, state: SessionState):
+        self._state = state
+
+    def instances(self, type: str | list[str]) -> None:
+        """Drop instances from the session.
+
+        Args:
+            type: The type of instances to drop.
+        """
+        type_list = type if isinstance(type, list) else [type]
+        uri_type_type = dict((v, k) for k, v in self._state.instances.store.queries.types.items())
+        selected_uri_by_type: dict[URIRef, str] = {}
+        for type_item in type_list:
+            if type_item not in uri_type_type:
+                print(f"Type {type_item} not found.")
+            selected_uri_by_type[uri_type_type[type_item]] = type_item
+
+        result = self._state.instances.store.queries.drop_types(list(selected_uri_by_type.keys()))
+
+        for type_uri, count in result.items():
+            print(f"Dropped {count} instances of type {selected_uri_by_type[type_uri]}")
+        return None

cognite/neat/_session/_inspect.py

@@ -11,6 +11,13 @@ from cognite.neat._utils.upload import UploadResult, UploadResultCore, UploadRes
 from ._state import SessionState
 from .exceptions import session_class_wrapper
 
+try:
+    from rich.markdown import Markdown as RichMarkdown
+
+    RICH_AVAILABLE = True
+except ImportError:
+    RICH_AVAILABLE = False
+
 
 @session_class_wrapper
 class InspectAPI:
@@ -61,14 +68,19 @@ class InspectIssues:
             closest_match = set(difflib.get_close_matches(search, unique_types))
             issues = IssueList([issue for issue in issues if type(issue).__name__ in closest_match])
 
+        issue_str = "\n".join(
+            [f"  * **{type(issue).__name__}**: {issue.as_message(include_type=False)}" for issue in issues]
+        )
+        markdown_str = f"### {len(issues)} issues found\n\n{issue_str}"
+
         if IN_NOTEBOOK:
             from IPython.display import Markdown, display
 
-            issue_str = "\n".join(
-                [f"  * **{type(issue).__name__}**: {issue.as_message(include_type=False)}" for issue in issues]
-            )
-            message = f"### {len(issues)} issues found\n\n{issue_str}"
-            display(Markdown(message))
+            display(Markdown(markdown_str))
+        elif RICH_AVAILABLE:
+            from rich import print
+
+            print(RichMarkdown(markdown_str))
 
         if return_dataframe:
             return issues.to_pandas()

cognite/neat/_session/_mapping.py

@@ -0,0 +1,39 @@
+from datetime import datetime, timezone
+
+from cognite.neat._rules.models.mapping import load_classic_to_core_mapping
+from cognite.neat._rules.transformers import RuleMapper
+from cognite.neat._store._provenance import Change
+
+from ._state import SessionState
+from .exceptions import session_class_wrapper
+
+
+@session_class_wrapper
+class MappingAPI:
+    def __init__(self, state: SessionState):
+        self._state = state
+
+    def classic_to_core(self, org_name: str) -> None:
+        """Map classic types to core types.
+
+        Note this automatically creates an extended CogniteCore model.
+
+        """
+        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))
+        output = transformer.transform(rules)
+        end = datetime.now(timezone.utc)
+
+        change = Change.from_rules_activity(
+            output,
+            transformer.agent,
+            start,
+            end,
+            "Mapping classic to core",
+            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)