cognite-neat 0.92.2__py3-none-any.whl → 0.93.0__py3-none-any.whl

cognite/neat/_rules/models/mapping/_classic2core.py

@@ -0,0 +1,150 @@
+from ._base import RuleMapping
+
+
+def create_classic_to_core_mapping() -> RuleMapping:
+    return RuleMapping.model_validate(_CLASSIC_TO_CORE)
+
+
+_CLASSIC_TO_CORE = {
+    "classes": [
+        {"destination": {"Class": "cdf_cdm:CogniteAsset"}, "source": {"Class": "classic:Asset"}},
+        {"destination": {"Class": "cdf_cdm:DataProduct"}, "source": {"Class": "classic:DataSet"}},
+        {"destination": {"Class": "cdf_cdm:CogniteActivity"}, "source": {"Class": "classic:Event"}},
+        {"destination": {"Class": "cdf_cdm:CogniteFile"}, "source": {"Class": "classic:File"}},
+        {"destination": {"Class": "cdf_cdm:CogniteTimeSeries"}, "source": {"Class": "classic:TimeSeries"}},
+    ],
+    "properties": [
+        {
+            "destination": {"Class": "cdf_cdm:CogniteAsset", "Property": "externalId"},
+            "source": {"Class": "classic:Asset", "Property": "externalId"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteAsset", "Property": "name"},
+            "source": {"Class": "classic:Asset", "Property": "name"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteAsset", "Property": "parent"},
+            "source": {"Class": "classic:Asset", "Property": "parentId"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteAsset", "Property": "description"},
+            "source": {"Class": "classic:Asset", "Property": "description"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteSourceSystem", "Property": "name"},
+            "source": {"Class": "classic:Asset", "Property": "source"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteAsset", "Property": "tag"},
+            "source": {"Class": "classic:Asset", "Property": "labels"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:DataProduct", "Property": "externalId"},
+            "source": {"Class": "classic:DataSet", "Property": "externalId"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:DataProduct", "Property": "name"},
+            "source": {"Class": "classic:DataSet", "Property": "name"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:DataProduct", "Property": "description"},
+            "source": {"Class": "classic:DataSet", "Property": "description"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:DataProduct", "Property": "metadata"},
+            "source": {"Class": "classic:DataSet", "Property": "metadata"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:DataProduct", "Property": "writeProtected"},
+            "source": {"Class": "classic:DataSet", "Property": "writeProtected"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteActivity", "Property": "externalId"},
+            "source": {"Class": "classic:Event", "Property": "externalId"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteSchedulable", "Property": "startTime"},
+            "source": {"Class": "classic:Event", "Property": "startTime"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteSchedulable", "Property": "endTime"},
+            "source": {"Class": "classic:Event", "Property": "endTime"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteActivity", "Property": "description"},
+            "source": {"Class": "classic:Event", "Property": "description"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteActivity", "Property": "assets"},
+            "source": {"Class": "classic:Event", "Property": "assetIds"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteSourceSystem", "Property": "name"},
+            "source": {"Class": "classic:Event", "Property": "source"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteFile", "Property": "externalId"},
+            "source": {"Class": "classic:File", "Property": "externalId"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteFile", "Property": "name"},
+            "source": {"Class": "classic:File", "Property": "name"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteFile", "Property": "directory"},
+            "source": {"Class": "classic:File", "Property": "directory"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteSourceSystem", "Property": "name"},
+            "source": {"Class": "classic:File", "Property": "source"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteFile", "Property": "mimeType"},
+            "source": {"Class": "classic:File", "Property": "mimeType"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteFile", "Property": "assets"},
+            "source": {"Class": "classic:File", "Property": "assetIds"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteFile", "Property": "sourceCreatedTime"},
+            "source": {"Class": "classic:File", "Property": "sourceCreatedTime"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteFile", "Property": "sourceUpdatedTime"},
+            "source": {"Class": "classic:File", "Property": "sourceModifiedTime"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteTimeSeries", "Property": "externalId"},
+            "source": {"Class": "classic:TimeSeries", "Property": "externalId"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteTimeSeries", "Property": "name"},
+            "source": {"Class": "classic:TimeSeries", "Property": "name"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteTimeSeries", "Property": "type"},
+            "source": {"Class": "classic:TimeSeries", "Property": "isString"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteTimeSeries", "Property": "sourceUnit"},
+            "source": {"Class": "classic:TimeSeries", "Property": "unit"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteTimeSeries", "Property": "unit"},
+            "source": {"Class": "classic:TimeSeries", "Property": "unitExternalId"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteTimeSeries", "Property": "assets"},
+            "source": {"Class": "classic:TimeSeries", "Property": "assetId"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteTimeSeries", "Property": "isStep"},
+            "source": {"Class": "classic:TimeSeries", "Property": "isStep"},
+        },
+        {
+            "destination": {"Class": "cdf_cdm:CogniteTimeSeries", "Property": "description"},
+            "source": {"Class": "classic:TimeSeries", "Property": "description"},
+        },
+    ],
+}

cognite/neat/{rules → _rules}/transformers/__init__.py

@@ -1,6 +1,15 @@
 from ._base import RulesPipeline, RulesTransformer
-from ._converters import AssetToInformation, ConvertToRules, DMSToInformation, InformationToAsset, InformationToDMS
-from ._map_onto import MapOneToOne
+from ._converters import (
+    AssetToInformation,
+    ConvertToRules,
+    DMSToInformation,
+    InformationToAsset,
+    InformationToDMS,
+    ReduceCogniteModel,
+    ToCompliantEntities,
+    ToExtension,
+)
+from ._mapping import MapOneToOne, RuleMapper
 from ._pipelines import ImporterPipeline
 from ._verification import VerifyAnyRules, VerifyAssetRules, VerifyDMSRules, VerifyInformationRules
 
@@ -18,4 +27,8 @@ __all__ = [
     "VerifyInformationRules",
     "VerifyAnyRules",
     "MapOneToOne",
+    "ToCompliantEntities",
+    "RuleMapper",
+    "ToExtension",
+    "ReduceCogniteModel",
 ]

cognite/neat/{rules → _rules}/transformers/_base.py

@@ -2,9 +2,9 @@ from abc import ABC, abstractmethod
 from collections.abc import MutableSequence
 from typing import Generic, TypeVar
 
-from cognite.neat.issues import IssueList, NeatError
-from cognite.neat.issues.errors import NeatTypeError, NeatValueError
-from cognite.neat.rules._shared import (
+from cognite.neat._issues import IssueList, NeatError
+from cognite.neat._issues.errors import NeatTypeError, NeatValueError
+from cognite.neat._rules._shared import (
     InputRules,
     JustRules,
     MaybeRules,

cognite/neat/{rules → _rules}/transformers/_converters.py

@@ -2,18 +2,23 @@ import re
 import warnings
 from abc import ABC, abstractmethod
 from collections import Counter, defaultdict
-from collections.abc import Collection
+from collections.abc import Collection, Mapping
 from datetime import date, datetime
 from typing import Literal, TypeVar, cast
 
 from cognite.client.data_classes import data_modeling as dms
+from cognite.client.data_classes.data_modeling import DataModelId, DataModelIdentifier, ViewId
 from rdflib import Namespace
 
-from cognite.neat.constants import DMS_CONTAINER_PROPERTY_SIZE_LIMIT
-from cognite.neat.issues.warnings.user_modeling import ParentInDifferentSpaceWarning
-from cognite.neat.rules._shared import JustRules, OutRules, VerifiedRules
-from cognite.neat.rules.models import (
+from cognite.neat._constants import COGNITE_MODELS, DMS_CONTAINER_PROPERTY_SIZE_LIMIT
+from cognite.neat._issues.errors import NeatValueError
+from cognite.neat._issues.warnings.user_modeling import ParentInDifferentSpaceWarning
+from cognite.neat._rules._constants import EntityTypes
+from cognite.neat._rules._shared import InputRules, JustRules, OutRules, VerifiedRules
+from cognite.neat._rules.analysis import DMSAnalysis
+from cognite.neat._rules.models import (
     AssetRules,
+    DMSInputRules,
     DMSRules,
     DomainRules,
     ExtensionCategory,
@@ -22,16 +27,15 @@ from cognite.neat.rules.models import (
     SheetList,
     data_types,
 )
-from cognite.neat.rules.models.data_types import DataType
-from cognite.neat.rules.models.dms import DMSMetadata, DMSProperty, DMSView
-from cognite.neat.rules.models.entities import (
+from cognite.neat._rules.models.data_types import DataType, String
+from cognite.neat._rules.models.dms import DMSMetadata, DMSProperty, DMSView
+from cognite.neat._rules.models.entities import (
     AssetEntity,
     AssetFields,
     ClassEntity,
     ContainerEntity,
     DMSUnknownEntity,
     EdgeEntity,
-    EntityTypes,
     MultiValueTypeInfo,
     ReferenceEntity,
     RelationshipEntity,
@@ -39,12 +43,19 @@ from cognite.neat.rules.models.entities import (
     UnknownEntity,
     ViewEntity,
 )
-from cognite.neat.rules.models.information import InformationClass, InformationMetadata, InformationProperty
+from cognite.neat._rules.models.information import InformationClass, InformationMetadata, InformationProperty
+from cognite.neat._rules.models.information._rules_input import (
+    InformationInputClass,
+    InformationInputProperty,
+    InformationInputRules,
+)
 
 from ._base import RulesTransformer
 
 T_VerifiedInRules = TypeVar("T_VerifiedInRules", bound=VerifiedRules)
 T_VerifiedOutRules = TypeVar("T_VerifiedOutRules", bound=VerifiedRules)
+T_InputInRules = TypeVar("T_InputInRules", bound=InputRules)
+T_InputOutRules = TypeVar("T_InputOutRules", bound=InputRules)
 
 
 class ConversionTransformer(RulesTransformer[T_VerifiedInRules, T_VerifiedOutRules], ABC):
@@ -59,6 +70,105 @@ class ConversionTransformer(RulesTransformer[T_VerifiedInRules, T_VerifiedOutRul
         raise NotImplementedError()
 
 
+class ToCompliantEntities(RulesTransformer[InformationInputRules, InformationInputRules]):  # type: ignore[misc]
+    """Converts input rules to rules with compliant entity IDs that match regex patters used
+    by DMS schema components."""
+
+    def transform(
+        self, rules: InformationInputRules | OutRules[InformationInputRules]
+    ) -> OutRules[InformationInputRules]:
+        return JustRules(self._transform(self._to_rules(rules)))
+
+    def _transform(self, rules: InformationInputRules) -> InformationInputRules:
+        rules.metadata.prefix = self._fix_entity(rules.metadata.prefix)
+        rules.classes = self._fix_classes(rules.classes)
+        rules.properties = self._fix_properties(rules.properties)
+        return rules
+
+    @classmethod
+    def _fix_entity(cls, entity: str) -> str:
+        entity = re.sub(r"[^_a-zA-Z0-9]+", "_", entity)
+
+        # entity id must start with a letter
+        if not entity[0].isalpha():
+            entity = "prefix_" + entity
+        # and end with a letter or number
+        if not entity[-1].isalnum():
+            entity = entity + "_suffix"
+
+        # removing any double underscores that could occur
+        return re.sub(r"[^a-zA-Z0-9]+", "_", entity)
+
+    @classmethod
+    def _fix_class(cls, class_: str | ClassEntity) -> str | ClassEntity:
+        if isinstance(class_, str):
+            if len(class_.split(":")) == 2:
+                prefix, suffix = class_.split(":")
+                class_ = f"{cls._fix_entity(prefix)}:{cls._fix_entity(suffix)}"
+
+            else:
+                class_ = cls._fix_entity(class_)
+
+        elif isinstance(class_, ClassEntity) and type(class_.prefix) is str:
+            class_ = ClassEntity(
+                prefix=cls._fix_entity(class_.prefix),
+                suffix=cls._fix_entity(class_.suffix),
+            )
+
+        return class_
+
+    @classmethod
+    def _fix_value_type(
+        cls, value_type: str | DataType | ClassEntity | MultiValueTypeInfo
+    ) -> str | DataType | ClassEntity | MultiValueTypeInfo:
+        fixed_value_type: str | DataType | ClassEntity | MultiValueTypeInfo
+
+        if isinstance(value_type, str):
+            # this is a multi value type but as string
+            if " | " in value_type:
+                value_types = value_type.split(" | ")
+                fixed_value_type = " | ".join([cast(str, cls._fix_value_type(v)) for v in value_types])
+            # this is value type specified with prefix:suffix string
+            elif ":" in value_type:
+                fixed_value_type = cls._fix_class(value_type)
+
+            # this is value type specified as suffix only
+            else:
+                fixed_value_type = cls._fix_entity(value_type)
+
+        # value type specified as instances of DataType, ClassEntity or MultiValueTypeInfo
+        elif isinstance(value_type, MultiValueTypeInfo):
+            fixed_value_type = MultiValueTypeInfo(
+                types=[cast(DataType | ClassEntity, cls._fix_value_type(type_)) for type_ in value_type.types],
+            )
+        elif isinstance(value_type, ClassEntity):
+            fixed_value_type = cls._fix_class(value_type)
+
+        # this is a DataType instance but also we should default to original value
+        else:
+            fixed_value_type = value_type
+
+        return fixed_value_type
+
+    @classmethod
+    def _fix_classes(cls, definitions: list[InformationInputClass]) -> list[InformationInputClass]:
+        fixed_definitions = []
+        for definition in definitions:
+            definition.class_ = cls._fix_class(definition.class_)
+            fixed_definitions.append(definition)
+        return fixed_definitions
+
+    @classmethod
+    def _fix_properties(cls, definitions: list[InformationInputProperty]) -> list[InformationInputProperty]:
+        fixed_definitions = []
+        for definition in definitions:
+            definition.class_ = cls._fix_class(definition.class_)
+            definition.property_ = cls._fix_entity(definition.property_)
+            definition.value_type = cls._fix_value_type(definition.value_type)
+            fixed_definitions.append(definition)
+        return fixed_definitions
+
+
 class InformationToDMS(ConversionTransformer[InformationRules, DMSRules]):
     """Converts InformationRules to DMSRules."""
 
@@ -114,6 +224,146 @@ class ConvertToRules(ConversionTransformer[VerifiedRules, VerifiedRules]):
         raise ValueError(f"Unsupported conversion from {type(rules)} to {self._out_cls}")
 
 
+_T_Entity = TypeVar("_T_Entity", bound=ClassEntity | ViewEntity)
+
+
+class ToExtension(RulesTransformer[DMSRules, DMSRules]):
+    def __init__(
+        self,
+        new_model_id: DataModelIdentifier,
+        org_name: str | None = None,
+        mode: Literal["composition"] = "composition",
+    ):
+        self.new_model_id = DataModelId.load(new_model_id)
+        self.org_name = org_name
+        self.mode = mode
+
+    def transform(self, rules: DMSRules | OutRules[DMSRules]) -> JustRules[DMSRules]:
+        # Copy to ensure immutability
+        verified = self._to_rules(rules)
+        if self.org_name is None and verified.metadata.as_data_model_id() in COGNITE_MODELS:
+            raise NeatValueError(f"Prefix is required when extending {verified.metadata.as_data_model_id()}")
+        source_id = verified.metadata.as_data_model_id()
+
+        dump = verified.dump()
+        dump["metadata"]["schema_"] = SchemaCompleteness.partial.value
+        dump["metadata"]["space"] = self.new_model_id.space
+        dump["metadata"]["external_id"] = self.new_model_id.external_id
+        if self.new_model_id.version is not None:
+            dump["metadata"]["version"] = self.new_model_id.version
+        # Serialize and deserialize to set the new space and external_id
+        # as the default values for the new model.
+        new_model = DMSRules.model_validate(DMSInputRules.load(dump).dump())
+
+        # Write back the original space and external_id for the container of the new model.
+        for prop in new_model.properties:
+            if prop.container and prop.container.space == self.new_model_id.space:
+                prop.container = ContainerEntity(
+                    space=source_id.space,
+                    externalId=prop.container.suffix,
+                )
+
+        if self.mode == "composition":
+            new_model.containers = None
+            for view in new_model.views:
+                view.implements = None
+
+        if source_id in COGNITE_MODELS:
+            # Remove CognitePrefixes.
+            for prop in new_model.properties:
+                prop.view = self._remove_cognite_prefix(prop.view)
+                prop.class_ = self._remove_cognite_prefix(prop.class_)
+                if isinstance(prop.value_type, ViewEntity):
+                    prop.value_type = self._remove_cognite_prefix(prop.value_type)
+            for view in new_model.views:
+                view.view = self._remove_cognite_prefix(view.view)
+                view.class_ = self._remove_cognite_prefix(view.class_)
+
+        return JustRules(new_model)
+
+    def _remove_cognite_prefix(self, entity: _T_Entity) -> _T_Entity:
+        new_suffix = entity.suffix.replace("Cognite", self.org_name or "")
+        if isinstance(entity, ViewEntity):
+            return ViewEntity(space=entity.space, externalId=new_suffix, version=entity.version)  # type: ignore[return-value]
+        elif isinstance(entity, ClassEntity):
+            return ClassEntity(prefix=entity.prefix, suffix=new_suffix, version=entity.version)  # type: ignore[return-value]
+        raise ValueError(f"Unsupported entity type: {type(entity)}")
+
+
+class ReduceCogniteModel(RulesTransformer[DMSRules, DMSRules]):
+    _ASSET_VIEW = ViewId("cdf_cdm", "CogniteAsset", "v1")
+    _VIEW_BY_COLLECTION: Mapping[Literal["3D", "Annotation", "BaseViews"], frozenset[ViewId]] = {
+        "3D": frozenset(
+            {
+                ViewId("cdf_cdm", "Cognite3DModel", "v1"),
+                ViewId("cdf_cdm", "Cognite3DObject", "v1"),
+                ViewId("cdf_cdm", "Cognite3DRevision", "v1"),
+                ViewId("cdf_cdm", "Cognite3DTransformation", "v1"),
+                ViewId("cdf_cdm", "Cognite360Image", "v1"),
+                ViewId("cdf_cdm", "Cognite360ImageAnnotation", "v1"),
+                ViewId("cdf_cdm", "Cognite360ImageCollection", "v1"),
+                ViewId("cdf_cdm", "Cognite360ImageModel", "v1"),
+                ViewId("cdf_cdm", "Cognite360ImageStation", "v1"),
+                ViewId("cdf_cdm", "CogniteCADModel", "v1"),
+                ViewId("cdf_cdm", "CogniteCADNode", "v1"),
+                ViewId("cdf_cdm", "CogniteCADRevision", "v1"),
+                ViewId("cdf_cdm", "CogniteCubeMap", "v1"),
+                ViewId("cdf_cdm", "CognitePointCloudModel", "v1"),
+                ViewId("cdf_cdm", "CognitePointCloudRevision", "v1"),
+                ViewId("cdf_cdm", "CognitePointCloudVolume", "v1"),
+            }
+        ),
+        "Annotation": frozenset(
+            {
+                ViewId("cdf_cdm", "CogniteAnnotation", "v1"),
+                ViewId("cdf_cdm", "CogniteDiagramAnnotation", "v1"),
+            }
+        ),
+        "BaseViews": frozenset(
+            {
+                ViewId("cdf_cdm", "CogniteDescribable", "v1"),
+                ViewId("cdf_cdm", "CogniteSchedulable", "v1"),
+                ViewId("cdf_cdm", "CogniteSourceable", "v1"),
+                ViewId("cdf_cdm", "CogniteVisualizable", "v1"),
+            }
+        ),
+    }
+
+    def __init__(self, drop: Collection[Literal["3D", "Annotation", "BaseViews"]]):
+        self.drop = drop
+
+    def transform(self, rules: DMSRules | OutRules[DMSRules]) -> JustRules[DMSRules]:
+        verified = self._to_rules(rules)
+        if verified.metadata.as_data_model_id() not in COGNITE_MODELS:
+            raise NeatValueError(f"Can only reduce Cognite Data Models, not {verified.metadata.as_data_model_id()}")
+        if invalid := (set(self.drop) - set(self._VIEW_BY_COLLECTION.keys())):
+            raise NeatValueError(f"Invalid drop values: {invalid}. Expected {set(self._VIEW_BY_COLLECTION)}")
+
+        exclude_views = {view for collection in self.drop for view in self._VIEW_BY_COLLECTION[collection]}
+        new_model = verified.model_copy(deep=True)
+
+        properties_by_view = DMSAnalysis(new_model).classes_with_properties(consider_inheritance=True)
+
+        new_model.views = SheetList[DMSView](
+            [view for view in new_model.views if view.view.as_id() not in exclude_views]
+        )
+        new_properties = SheetList[DMSProperty]()
+        for view in new_model.views:
+            for prop in properties_by_view[view.view]:
+                if self._is_asset_3D_property(prop):
+                    # We filter out the 3D property of asset
+                    continue
+                new_properties.append(prop)
+        new_model.properties = new_properties
+
+        return JustRules(new_model)
+
+    def _is_asset_3D_property(self, prop: DMSProperty) -> bool:
+        if "3D" not in self.drop:
+            return False
+        return prop.view.as_id() == self._ASSET_VIEW and prop.property_ == "object3D"
+
+
 class _InformationRulesConverter:
     def __init__(self, information: InformationRules):
         self.rules = information
@@ -135,7 +385,7 @@ class _InformationRulesConverter:
         raise NotImplementedError("DomainRules not implemented yet")
 
     def as_asset_architect_rules(self) -> "AssetRules":
-        from cognite.neat.rules.models.asset._rules import AssetClass, AssetMetadata, AssetProperty, AssetRules
+        from cognite.neat._rules.models.asset._rules import AssetClass, AssetMetadata, AssetProperty, AssetRules
 
         classes: SheetList[AssetClass] = SheetList[AssetClass](
             [AssetClass(**class_.model_dump()) for class_ in self.rules.classes]
@@ -157,7 +407,7 @@ class _InformationRulesConverter:
         )
 
     def as_dms_rules(self, ignore_undefined_value_types: bool = False) -> "DMSRules":
-        from cognite.neat.rules.models.dms._rules import (
+        from cognite.neat._rules.models.dms._rules import (
             DMSContainer,
             DMSProperty,
             DMSRules,
@@ -252,7 +502,7 @@ class _InformationRulesConverter:
 
     @classmethod
     def _convert_metadata_to_dms(cls, metadata: InformationMetadata) -> "DMSMetadata":
-        from cognite.neat.rules.models.dms._rules import (
+        from cognite.neat._rules.models.dms._rules import (
             DMSMetadata,
         )
 
@@ -273,18 +523,35 @@ class _InformationRulesConverter:
     def _as_dms_property(self, prop: InformationProperty, default_space: str, default_version: str) -> "DMSProperty":
         """This creates the first"""
 
-        from cognite.neat.rules.models.dms._rules import DMSProperty
+        from cognite.neat._rules.models.dms._rules import DMSProperty
 
         # returns property type, which can be ObjectProperty or DatatypeProperty
         value_type: DataType | ViewEntity | DMSUnknownEntity
         if isinstance(prop.value_type, DataType):
             value_type = prop.value_type
+
+        # UnknownEntity should  resolve to DMSUnknownEntity
+        # meaning end node type is unknown
         elif isinstance(prop.value_type, UnknownEntity):
             value_type = DMSUnknownEntity()
+
         elif isinstance(prop.value_type, ClassEntity):
             value_type = prop.value_type.as_view_entity(default_space, default_version)
+
         elif isinstance(prop.value_type, MultiValueTypeInfo):
-            value_type = self.convert_multi_value_type(prop.value_type)
+            # Multi Object type should resolve to DMSUnknownEntity
+            # meaning end node type is unknown
+            if prop.value_type.is_multi_object_type():
+                value_type = DMSUnknownEntity()
+
+            # Multi Data type should resolve to a single data type, or it should
+            elif prop.value_type.is_multi_data_type():
+                value_type = self.convert_multi_data_type(prop.value_type)
+
+            # Mixed types default to string
+            else:
+                value_type = String()
+
         else:
             raise ValueError(f"Unsupported value type: {prop.value_type.type_}")
 
@@ -391,13 +658,15 @@ class _InformationRulesConverter:
             return f"{suffix}2"
 
     @staticmethod
-    def convert_multi_value_type(value_type: MultiValueTypeInfo) -> DataType:
-        if not all(isinstance(type_, DataType) for type_ in value_type.types):
+    def convert_multi_data_type(value_type: MultiValueTypeInfo) -> DataType:
+        if not value_type.is_multi_data_type():
             raise ValueError("Only MultiValueType with DataType types is supported")
         # We check above that there are no ClassEntity types in the MultiValueType
         py_types = {type_.python for type_ in value_type.types}  # type: ignore[union-attr]
+
+        # JSON mixed with other types should resolve to string that is safe choice
         if dms.Json in py_types and len(py_types) > 1:
-            raise ValueError("MultiValueType with Json and other types is not supported")
+            return data_types.String()
         elif dms.Json in py_types:
             return data_types.Json()
         elif not (py_types - {bool}):
@@ -422,7 +691,7 @@ class _DMSRulesConverter:
     def as_information_rules(
         self,
     ) -> "InformationRules":
-        from cognite.neat.rules.models.information._rules import (
+        from cognite.neat._rules.models.information._rules import (
             InformationClass,
             InformationProperty,
             InformationRules,
@@ -487,7 +756,7 @@ class _DMSRulesConverter:
 
     @classmethod
     def _convert_metadata_to_info(cls, metadata: DMSMetadata) -> "InformationMetadata":
-        from cognite.neat.rules.models.information._rules import InformationMetadata
+        from cognite.neat._rules.models.information._rules import InformationMetadata
 
         prefix = metadata.space
         return InformationMetadata(

cognite/neat/{rules/transformers/_map_onto.py → _rules/transformers/_mapping.py}

@@ -1,10 +1,13 @@
 from abc import ABC
 from collections import defaultdict
 
-from cognite.neat.rules._shared import JustRules, OutRules
-from cognite.neat.rules.models import DMSRules
-from cognite.neat.rules.models.dms import DMSProperty
-from cognite.neat.rules.models.entities import ReferenceEntity
+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, ReferenceEntity
+from cognite.neat._rules.models.information import InformationClass
+from cognite.neat._rules.models.mapping import RuleMapping
 
 from ._base import RulesTransformer
 
@@ -95,3 +98,42 @@ class MapOneToOne(MapOntoTransformers):
                 prop.reference = ReferenceEntity.from_entity(ref_prop.view, ref_prop.view_property)
 
         return JustRules(solution)
+
+
+class RuleMapper(RulesTransformer[InformationRules, InformationRules]):
+    """Maps properties and classes using the given mapping.
+
+    **Note**: This transformer mutates the input rules.
+
+    Args:
+        mapping: The mapping to use.
+
+    """
+
+    def __init__(self, mapping: RuleMapping) -> None:
+        self.mapping = mapping
+
+    def transform(self, rules: InformationRules | OutRules[InformationRules]) -> JustRules[InformationRules]:
+        input_rules = self._to_rules(rules)
+
+        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)