cognite-neat 0.107.0__py3-none-any.whl → 0.108.0__py3-none-any.whl

cognite/neat/_rules/importers/_dtdl2rules/spec.py

@@ -302,8 +302,7 @@ class Interface(DTDLBase):
     spec_version = frozenset(["2", "3"])
     default_context: ClassVar[IRI] = Field(
         "dtmi:dtdl:context;3",
-        description="This can be set directly on the class to change the "
-        "default context used when parsing a document.",
+        description="This can be set directly on the class to change the default context used when parsing a document.",
     )
     id_: DTMI = Field(alias="@id")  # type: ignore[assignment]
     context: IRI | None = Field(alias="@context")

cognite/neat/_rules/importers/_rdf/__init__.py

@@ -1,5 +1,5 @@
 from ._imf2rules import IMFImporter
-from ._inference2rules import InferenceImporter
+from ._inference2rules import InferenceImporter, SubclassInferenceImporter
 from ._owl2rules import OWLImporter
 
-__all__ = ["IMFImporter", "InferenceImporter", "OWLImporter"]
+__all__ = ["IMFImporter", "InferenceImporter", "OWLImporter", "SubclassInferenceImporter"]

cognite/neat/_rules/importers/_rdf/_base.py

@@ -72,7 +72,7 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
     ):
         return cls(
             IssueList(title=f"{cls.__name__} issues"),
-            store.graph,
+            store.dataset,
             data_model_id=data_model_id,
             max_number_of_instance=max_number_of_instance,
             non_existing_node_type=non_existing_node_type,
@@ -140,7 +140,7 @@ class BaseRDFImporter(BaseImporter[InformationInputRules]):
             prefixes: Dict of prefixes and namespaces
         """
         if Namespace(get_namespace(URI)) not in prefixes.values():
-            prefixes[f"prefix_{len(prefixes)+1}"] = Namespace(get_namespace(URI))
+            prefixes[f"prefix_{len(prefixes) + 1}"] = Namespace(get_namespace(URI))
 
     @property
     def _metadata(self) -> dict:

cognite/neat/_rules/importers/_rdf/_inference2rules.py

@@ -1,18 +1,25 @@
+import itertools
 from collections import Counter, defaultdict
-from collections.abc import Mapping
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import ClassVar, cast
+from typing import Any, ClassVar, cast
 
 from cognite.client import data_modeling as dm
-from rdflib import RDF, Namespace, URIRef
+from rdflib import RDF, Graph, Namespace, URIRef
 from rdflib import Literal as RdfLiteral
 
-from cognite.neat._issues.warnings import PropertySkippedWarning, PropertyValueTypeUndefinedWarning
-from cognite.neat._rules.models import data_types
+from cognite.neat._constants import NEAT
+from cognite.neat._issues import IssueList
+from cognite.neat._issues.warnings import PropertyValueTypeUndefinedWarning
+from cognite.neat._rules.analysis import InformationAnalysis
+from cognite.neat._rules.models import InformationRules, data_types
 from cognite.neat._rules.models.data_types import AnyURI
 from cognite.neat._rules.models.entities._single_value import UnknownEntity
 from cognite.neat._rules.models.information import (
+    InformationInputClass,
+    InformationInputProperty,
     InformationMetadata,
 )
 from cognite.neat._store import NeatGraphStore
@@ -157,7 +164,7 @@ class InferenceImporter(BaseRDFImporter):
         for class_uri, no_instances in self.graph.query(ORDERED_CLASSES_QUERY):  # type: ignore[misc]
             if (class_id := remove_namespace_from_uri(cast(URIRef, class_uri))) in classes:
                 # handles cases when class id is already present in classes
-                class_id = f"{class_id}_{len(classes)+1}"
+                class_id = f"{class_id}_{len(classes) + 1}"
 
             classes[class_id] = {
                 "class_": class_id,
@@ -190,18 +197,6 @@ class InferenceImporter(BaseRDFImporter):
                     if property_uri == RDF.type:
                         continue
                     property_id = remove_namespace_from_uri(property_uri)
-                    if property_id in {"external_id", "externalId"}:
-                        skip_issue = PropertySkippedWarning(
-                            resource_type="Property",
-                            identifier=f"{class_id}:{property_id}",
-                            property_name=property_id,
-                            reason="External ID is assumed to be the unique identifier of the instance "
-                            "and is not part of the data model schema.",
-                        )
-                        if skip_issue not in self.issue_list:
-                            self.issue_list.append(skip_issue)
-                        continue
-
                     self._add_uri_namespace_to_prefixes(cast(URIRef, property_uri), prefixes)
 
                     if isinstance(data_type_uri, URIRef):
@@ -292,3 +287,231 @@ class InferenceImporter(BaseRDFImporter):
     @property
     def source_uri(self) -> URIRef:
         return INSTANCES_ENTITY.id_
+
+
+# Internal helper class
+@dataclass
+class _ReadProperties:
+    class_uri: URIRef
+    subclass_uri: URIRef
+    property_uri: URIRef
+    data_type: URIRef | None
+    object_type: URIRef | None
+    max_occurrence: int
+    instance_count: int
+
+
+class SubclassInferenceImporter(BaseRDFImporter):
+    """Infer subclasses from a triple store.
+
+    Assumes that the graph already is connected to a schema. The classes should
+    match the RDF.type of the instances in the graph, while the subclasses should
+    match the NEAT.type of the instances in the graph.
+
+    ClassVars:
+        overwrite_data_types: Mapping of data types to be overwritten. The InferenceImporter will overwrite
+            32-bit integer and 32-bit float data types to 64-bit integer and 64-bit float data types
+
+    Args:
+        issue_list: Issue list to store issues
+        graph: Knowledge graph
+        max_number_of_instance: Maximum number of instances to be used in inference
+    """
+
+    overwrite_data_types: ClassVar[Mapping[URIRef, URIRef]] = {
+        data_types.Integer.as_xml_uri_ref(): data_types.Long.as_xml_uri_ref(),
+        data_types.Float.as_xml_uri_ref(): data_types.Double.as_xml_uri_ref(),
+    }
+
+    def __init__(
+        self,
+        issue_list: IssueList,
+        graph: Graph,
+        rules: InformationRules,
+        max_number_of_instance: int,
+        non_existing_node_type: UnknownEntity | AnyURI = DEFAULT_NON_EXISTING_NODE_TYPE,
+    ) -> None:
+        super().__init__(
+            issue_list,
+            graph,
+            rules.metadata.as_data_model_id().as_tuple(),  # type: ignore[arg-type]
+            max_number_of_instance,
+            non_existing_node_type,
+            language="en",
+        )
+        self._rules = rules
+
+    _ordered_subclass_query = f"""SELECT DISTINCT ?class ?subclass (count(?s) as ?instances )
+                           WHERE {{ ?s a ?class . ?s <{NEAT.type}> ?subclass }}
+                           group by ?class ?subclass order by DESC(?instances)"""
+
+    _properties_query = """SELECT DISTINCT ?property ?dataType ?objectType
+                         WHERE {{
+                            ?s a <{type}> .
+                            ?s <{neat_type}> <{subtype}> .
+                            ?s ?property ?value .
+                            BIND(datatype(?value) AS ?dataType) .
+                            OPTIONAL {{?value rdf:type ?objectType}}
+                        }}"""
+
+    _max_occurrence_query = """SELECT (MAX(?count) AS ?maxCount)
+                            WHERE {{
+                              {{
+                                SELECT ?subject (COUNT(?object) AS ?count)
+                                WHERE {{
+                                  ?subject a <{type}> .
+                                  ?subject <{neat_type}> <{subtype}> .
+                                  ?subject <{property}> ?object .
+                                }}
+                                GROUP BY ?subject
+                              }}
+                            }}"""
+
+    def _to_rules_components(
+        self,
+    ) -> dict:
+        properties_by_class_subclass_pair = self._read_class_properties_from_graph()
+        existing_classes = {class_.class_.suffix: class_ for class_ in self._rules.classes}
+        prefixes = self._rules.prefixes.copy()
+
+        classes: list[InformationInputClass] = []
+        properties: list[InformationInputProperty] = []
+        # Help for IDE
+        subclass_uri: URIRef
+        for class_uri, class_properties_iterable in itertools.groupby(
+            properties_by_class_subclass_pair, key=lambda x: x.class_uri
+        ):
+            properties_by_subclass_by_property = self._get_properties_by_subclass_by_property(class_properties_iterable)
+
+            shared_property_uris = set.intersection(
+                *[
+                    set(properties_by_property.keys())
+                    for properties_by_property in properties_by_subclass_by_property.values()
+                ]
+            )
+            class_suffix = remove_namespace_from_uri(class_uri)
+            self._add_uri_namespace_to_prefixes(class_uri, prefixes)
+            if class_suffix not in existing_classes:
+                classes.append(InformationInputClass(class_=class_suffix))
+            else:
+                classes.append(InformationInputClass.load(existing_classes[class_suffix].model_dump()))
+            shared_properties: dict[URIRef, list[_ReadProperties]] = defaultdict(list)
+            for subclass_uri, properties_by_property_uri in properties_by_subclass_by_property.items():
+                subclass_suffix = remove_namespace_from_uri(subclass_uri)
+                self._add_uri_namespace_to_prefixes(subclass_uri, prefixes)
+                if subclass_suffix not in existing_classes:
+                    classes.append(InformationInputClass(class_=subclass_suffix, implements=class_suffix))
+                else:
+                    classes.append(InformationInputClass.load(existing_classes[subclass_suffix].model_dump()))
+                for property_uri, read_properties in properties_by_property_uri.items():
+                    if property_uri in shared_property_uris:
+                        shared_properties[property_uri].extend(read_properties)
+                        continue
+                    properties.append(
+                        self._create_property(read_properties, subclass_suffix, class_uri, property_uri, prefixes)
+                    )
+            for property_uri, read_properties in shared_properties.items():
+                properties.append(
+                    self._create_property(read_properties, class_suffix, class_uri, property_uri, prefixes)
+                )
+
+        return {
+            "metadata": self._rules.metadata.model_dump(),
+            "classes": [cls.dump(self._rules.metadata.prefix) for cls in classes],
+            "properties": [prop.dump(self._rules.metadata.prefix) for prop in properties],
+            "prefixes": self._rules.prefixes,
+        }
+
+    @staticmethod
+    def _get_properties_by_subclass_by_property(
+        class_properties_iterable: Iterable[_ReadProperties],
+    ) -> dict[URIRef, dict[URIRef, list[_ReadProperties]]]:
+        properties_by_subclass_by_property: dict[URIRef, dict[URIRef, list[_ReadProperties]]] = {}
+        for subclass_uri, subclass_properties_iterable in itertools.groupby(
+            class_properties_iterable, key=lambda x: x.subclass_uri
+        ):
+            properties_by_subclass_by_property[subclass_uri] = defaultdict(list)
+            for read_prop in subclass_properties_iterable:
+                properties_by_subclass_by_property[subclass_uri][read_prop.property_uri].append(read_prop)
+        return properties_by_subclass_by_property
+
+    def _read_class_properties_from_graph(self) -> list[_ReadProperties]:
+        count_by_class_subclass_pair: dict[tuple[URIRef, URIRef], int] = {}
+        # Infers all the classes w in the graph
+        for result_row in self.graph.query(self._ordered_subclass_query):
+            class_uri, subclass_uri, instance_count_literal = cast(tuple[URIRef, URIRef, RdfLiteral], result_row)
+            count_by_class_subclass_pair[(class_uri, subclass_uri)] = instance_count_literal.toPython()
+        analysis = InformationAnalysis(self._rules)
+        existing_class_properties = {
+            (class_entity.suffix, property)
+            for class_entity, properties in analysis.class_property_pairs(consider_inheritance=True).items()
+            for property in properties.keys()
+        }
+        properties_by_class_by_subclass: list[_ReadProperties] = []
+        for (class_uri, subclass_uri), instance_count in count_by_class_subclass_pair.items():
+            property_query = self._properties_query.format(type=class_uri, subtype=subclass_uri, neat_type=NEAT.type)
+            class_suffix = remove_namespace_from_uri(class_uri)
+            for result_row in self.graph.query(property_query):
+                property_uri, data_type_uri, object_type_uri = cast(tuple[URIRef, URIRef, URIRef], result_row)
+                if property_uri == RDF.type or property_uri == NEAT.type:
+                    continue
+                property_str = remove_namespace_from_uri(property_uri)
+                if (class_suffix, property_str) in existing_class_properties:
+                    continue
+                occurrence_query = self._max_occurrence_query.format(
+                    type=class_uri, subtype=subclass_uri, property=property_uri, neat_type=NEAT.type
+                )
+                max_occurrence = 1  # default value
+                result_row, *_ = list(self.graph.query(occurrence_query))
+                if result_row:
+                    max_occurrence_literal, *__ = cast(tuple[RdfLiteral, Any], result_row)
+                    max_occurrence = int(max_occurrence_literal.toPython())
+                properties_by_class_by_subclass.append(
+                    _ReadProperties(
+                        class_uri=class_uri,
+                        subclass_uri=subclass_uri,
+                        property_uri=property_uri,
+                        data_type=data_type_uri,
+                        object_type=object_type_uri,
+                        max_occurrence=max_occurrence,
+                        instance_count=instance_count,
+                    )
+                )
+        return properties_by_class_by_subclass
+
+    def _create_property(
+        self,
+        read_properties: list[_ReadProperties],
+        class_suffix: str,
+        class_uri: URIRef,
+        property_uri: URIRef,
+        prefixes: dict[str, Namespace],
+    ) -> InformationInputProperty:
+        first = read_properties[0]
+        value_type = self._get_value_type(read_properties, prefixes)
+        property_name = remove_namespace_from_uri(property_uri)
+        self._add_uri_namespace_to_prefixes(property_uri, prefixes)
+
+        return InformationInputProperty(
+            class_=class_suffix,
+            property_=property_name,
+            max_count=first.max_occurrence,
+            value_type=value_type,
+            instance_source=(f"{uri_to_short_form(class_uri, prefixes)}({uri_to_short_form(property_uri, prefixes)})"),
+        )
+
+    def _get_value_type(
+        self, read_properties: list[_ReadProperties], prefixes: dict[str, Namespace]
+    ) -> str | UnknownEntity:
+        value_types = {prop.data_type for prop in read_properties if prop.data_type} | {
+            prop.object_type for prop in read_properties if prop.object_type
+        }
+        if len(value_types) == 1:
+            uri_ref = value_types.pop()
+            self._add_uri_namespace_to_prefixes(uri_ref, prefixes)
+            return remove_namespace_from_uri(uri_ref)
+        elif len(value_types) == 0:
+            return UnknownEntity()
+        for uri_ref in value_types:
+            self._add_uri_namespace_to_prefixes(uri_ref, prefixes)
+        return " | ".join(remove_namespace_from_uri(uri_ref) for uri_ref in value_types)

cognite/neat/_rules/models/_base_rules.py

@@ -21,6 +21,7 @@ from typing import (
 )
 
 import pandas as pd
+from cognite.client import data_modeling as dm
 from pydantic import (
     BaseModel,
     BeforeValidator,
@@ -180,6 +181,12 @@ class BaseMetadata(SchemaModel):
         description="Date of the data model update",
     )
 
+    source_id: URIRefType | None = Field(
+        None,
+        description="Id of source that produced this rules",
+        alias="sourceId",
+    )
+
     @field_validator("*", mode="before")
     def strip_string(cls, value: Any) -> Any:
         if isinstance(value, str):
@@ -213,9 +220,6 @@ class BaseMetadata(SchemaModel):
     def prefix(self) -> str:
         return self.space
 
-    def as_identifier(self) -> str:
-        return f"{self.prefix}:{self.external_id}"
-
     def get_prefix(self) -> str:
         return self.prefix
 
@@ -234,6 +238,12 @@ class BaseMetadata(SchemaModel):
         """Namespace for the data model used for the entities in the data model."""
         return Namespace(f"{self.identifier}/")
 
+    def as_data_model_id(self) -> dm.DataModelId:
+        return dm.DataModelId(space=self.space, external_id=self.external_id, version=self.version)
+
+    def as_identifier(self) -> str:
+        return repr(self.as_data_model_id())
+
 
 class BaseRules(SchemaModel, ABC):
     """

cognite/neat/_rules/models/dms/_rules.py

@@ -64,9 +64,6 @@ class DMSMetadata(BaseMetadata):
             space=self.space,
         )
 
-    def as_data_model_id(self) -> dm.DataModelId:
-        return dm.DataModelId(space=self.space, external_id=self.external_id, version=self.version)
-
     def as_data_model(self) -> dm.DataModelApply:
         suffix = f"Creator: {', '.join(self.creator)}"
         if self.description:
@@ -83,9 +80,6 @@ class DMSMetadata(BaseMetadata):
             views=[],
         )
 
-    def as_identifier(self) -> str:
-        return repr(self.as_data_model_id())
-
     def get_prefix(self) -> str:
         return self.space
 
@@ -109,8 +103,7 @@ class DMSProperty(SheetRow):
     )
     value_type: DataType | ViewEntity | DMSUnknownEntity = Field(
         alias="Value Type",
-        description="Value type that the property can hold. "
-        "It takes either subset of CDF primitive types or a View id",
+        description="Value type that the property can hold. It takes either subset of CDF primitive types or a View id",
     )
     nullable: bool | None = Field(
         default=None,

cognite/neat/_rules/models/dms/_rules_input.py

@@ -37,6 +37,7 @@ class DMSInputMetadata(InputComponent[DMSMetadata]):
     created: datetime | str | None = None
     updated: datetime | str | None = None
     logical: str | URIRef | None = None
+    source_id: str | URIRef | None = None
 
     @classmethod
     def _get_verified_cls(cls) -> type[DMSMetadata]:
@@ -77,6 +78,9 @@ class DMSInputMetadata(InputComponent[DMSMetadata]):
             description = None
         return description, creator
 
+    def as_data_model_id(self) -> dm.DataModelId:
+        return dm.DataModelId(space=self.space, external_id=self.external_id, version=self.version)
+
     @property
     def identifier(self) -> URIRef:
         """Globally unique identifier for the data model.

cognite/neat/_rules/models/information/_rules_input.py

@@ -3,6 +3,7 @@ from datetime import datetime
 from typing import Any
 
 import pandas as pd
+from cognite.client import data_modeling as dm
 from rdflib import Namespace, URIRef
 
 from cognite.neat._constants import DEFAULT_NAMESPACE
@@ -36,6 +37,7 @@ class InformationInputMetadata(InputComponent[InformationMetadata]):
     updated: datetime | str | None = None
     physical: str | URIRef | None = None
     conceptual: str | URIRef | None = None
+    source_id: str | URIRef | None = None
 
     @classmethod
     def _get_verified_cls(cls) -> type[InformationMetadata]:
@@ -49,6 +51,9 @@ class InformationInputMetadata(InputComponent[InformationMetadata]):
             output["updated"] = datetime.now()
         return output
 
+    def as_data_model_id(self) -> dm.DataModelId:
+        return dm.DataModelId(space=self.space, external_id=self.external_id, version=self.version)
+
     @property
     def prefix(self) -> str:
         return self.space

cognite/neat/_rules/transformers/__init__.py

@@ -3,10 +3,13 @@ from ._converters import (
     AddClassImplements,
     ChangeViewPrefix,
     ClassicPrepareCore,
+    ConversionTransformer,
     ConvertToRules,
     DMSToInformation,
     IncludeReferenced,
     InformationToDMS,
+    MergeDMSRules,
+    MergeInformationRules,
     PrefixEntities,
     ReduceCogniteModel,
     SetIDDMSModel,
@@ -24,11 +27,14 @@ __all__ = [
     "AsParentPropertyId",
     "ChangeViewPrefix",
     "ClassicPrepareCore",
+    "ConversionTransformer",
     "ConvertToRules",
     "DMSToInformation",
     "IncludeReferenced",
     "InformationToDMS",
     "MapOneToOne",
+    "MergeDMSRules",
+    "MergeInformationRules",
     "PrefixEntities",
     "ReduceCogniteModel",
     "RuleMapper",

cognite/neat/_rules/transformers/_converters.py

@@ -16,6 +16,7 @@ from cognite.neat._client.data_classes.data_modeling import ContainerApplyDict,
 from cognite.neat._constants import (
     COGNITE_MODELS,
     DMS_CONTAINER_PROPERTY_SIZE_LIMIT,
+    DMS_RESERVED_PROPERTIES,
     get_default_prefixes_and_namespaces,
 )
 from cognite.neat._issues.errors import NeatValueError
@@ -41,9 +42,9 @@ from cognite.neat._rules.models import (
 )
 from cognite.neat._rules.models._rdfpath import Entity as RDFPathEntity
 from cognite.neat._rules.models._rdfpath import RDFPath, SingleProperty
-from cognite.neat._rules.models.data_types import AnyURI, DataType, String
+from cognite.neat._rules.models.data_types import AnyURI, DataType, Enum, File, String, Timeseries
 from cognite.neat._rules.models.dms import DMSMetadata, DMSProperty, DMSValidation, DMSView
-from cognite.neat._rules.models.dms._rules import DMSContainer
+from cognite.neat._rules.models.dms._rules import DMSContainer, DMSEnum, DMSNode
 from cognite.neat._rules.models.entities import (
     ClassEntity,
     ContainerEntity,
@@ -252,11 +253,16 @@ class PrefixEntities(RulesTransformer[ReadRules[T_InputRules], ReadRules[T_Input
 class InformationToDMS(ConversionTransformer[InformationRules, DMSRules]):
     """Converts InformationRules to DMSRules."""
 
-    def __init__(self, ignore_undefined_value_types: bool = False):
+    def __init__(
+        self, ignore_undefined_value_types: bool = False, reserved_properties: Literal["error", "skip"] = "error"
+    ):
         self.ignore_undefined_value_types = ignore_undefined_value_types
+        self.reserved_properties = reserved_properties
 
     def transform(self, rules: InformationRules) -> DMSRules:
-        return _InformationRulesConverter(rules).as_dms_rules(self.ignore_undefined_value_types)
+        return _InformationRulesConverter(rules).as_dms_rules(
+            self.ignore_undefined_value_types, self.reserved_properties
+        )
 
 
 class DMSToInformation(ConversionTransformer[DMSRules, InformationRules]):
@@ -823,11 +829,21 @@ class ClassicPrepareCore(RulesTransformer[InformationRules, InformationRules]):
     - ClassicTimeseries.isString from boolean to string
     - Add class ClassicSourceSystem, and update all source properties from string to ClassicSourceSystem.
     - Rename externalId properties to classicExternalId
-    - Renames the Relationship.sourceExternaId and Relationship.targetExternalId to startNode and endNode
+    - Renames the Relationship.sourceExternalId and Relationship.targetExternalId to startNode and endNode
+    - If reference_timeseries is True, the classicExternalId property of the TimeSeries class will change type
+      from string to timeseries.
+    - If reference_files is True, the classicExternalId property of the File class will change type from string to file.
     """
 
-    def __init__(self, instance_namespace: Namespace) -> None:
+    def __init__(
+        self,
+        instance_namespace: Namespace,
+        reference_timeseries: bool = False,
+        reference_files: bool = False,
+    ) -> None:
         self.instance_namespace = instance_namespace
+        self.reference_timeseries = reference_timeseries
+        self.reference_files = reference_files
 
     @property
     def description(self) -> str:
@@ -851,6 +867,10 @@ class ClassicPrepareCore(RulesTransformer[InformationRules, InformationRules]):
                 prop.value_type = ClassEntity(prefix=prefix, suffix="ClassicSourceSystem")
             elif prop.property_ == "externalId":
                 prop.property_ = "classicExternalId"
+                if self.reference_timeseries and prop.class_.suffix == "ClassicTimeSeries":
+                    prop.value_type = Timeseries()
+                elif self.reference_files and prop.class_.suffix == "ClassicFile":
+                    prop.value_type = File()
             elif prop.property_ == "sourceExternalId" and prop.class_.suffix == "ClassicRelationship":
                 prop.property_ = "startNode"
             elif prop.property_ == "targetExternalId" and prop.class_.suffix == "ClassicRelationship":
@@ -907,6 +927,68 @@ class ChangeViewPrefix(RulesTransformer[DMSRules, DMSRules]):
         return output
 
 
+class MergeDMSRules(RulesTransformer[DMSRules, DMSRules]):
+    def __init__(self, extra: DMSRules) -> None:
+        self.extra = extra
+
+    def transform(self, rules: DMSRules) -> DMSRules:
+        output = rules.model_copy(deep=True)
+        existing_views = {view.view for view in output.views}
+        for view in self.extra.views:
+            if view.view not in existing_views:
+                output.views.append(view)
+        existing_properties = {(prop.view, prop.view_property) for prop in output.properties}
+        existing_containers = {container.container for container in output.containers or []}
+        existing_enum_collections = {collection.collection for collection in output.enum or []}
+        new_containers_by_entity = {container.container: container for container in self.extra.containers or []}
+        new_enum_collections_by_entity = {collection.collection: collection for collection in self.extra.enum or []}
+        for prop in self.extra.properties:
+            if (prop.view, prop.view_property) in existing_properties:
+                continue
+            output.properties.append(prop)
+            if prop.container and prop.container not in existing_containers:
+                if output.containers is None:
+                    output.containers = SheetList[DMSContainer]()
+                output.containers.append(new_containers_by_entity[prop.container])
+            if isinstance(prop.value_type, Enum) and prop.value_type.collection not in existing_enum_collections:
+                if output.enum is None:
+                    output.enum = SheetList[DMSEnum]()
+                output.enum.append(new_enum_collections_by_entity[prop.value_type.collection])
+
+        existing_nodes = {node.node for node in output.nodes or []}
+        for node in self.extra.nodes or []:
+            if node.node not in existing_nodes:
+                if output.nodes is None:
+                    output.nodes = SheetList[DMSNode]()
+                output.nodes.append(node)
+
+        return output
+
+    @property
+    def description(self) -> str:
+        return f"Merged with {self.extra.metadata.as_data_model_id()}"
+
+
+class MergeInformationRules(RulesTransformer[InformationRules, InformationRules]):
+    def __init__(self, extra: InformationRules) -> None:
+        self.extra = extra
+
+    def transform(self, rules: InformationRules) -> InformationRules:
+        output = rules.model_copy(deep=True)
+        existing_classes = {cls.class_ for cls in output.classes}
+        for cls in self.extra.classes:
+            if cls.class_ not in existing_classes:
+                output.classes.append(cls)
+        existing_properties = {(prop.class_, prop.property_) for prop in output.properties}
+        for prop in self.extra.properties:
+            if (prop.class_, prop.property_) not in existing_properties:
+                output.properties.append(prop)
+        for prefix, namespace in self.extra.prefixes.items():
+            if prefix not in output.prefixes:
+                output.prefixes[prefix] = namespace
+        return output
+
+
 class _InformationRulesConverter:
     _start_or_end_node: ClassVar[frozenset[str]] = frozenset({"endNode", "end_node", "startNode", "start_node"})
 
@@ -914,7 +996,9 @@ class _InformationRulesConverter:
         self.rules = information
         self.property_count_by_container: dict[ContainerEntity, int] = defaultdict(int)
 
-    def as_dms_rules(self, ignore_undefined_value_types: bool = False) -> "DMSRules":
+    def as_dms_rules(
+        self, ignore_undefined_value_types: bool = False, reserved_properties: Literal["error", "skip"] = "error"
+    ) -> "DMSRules":
         from cognite.neat._rules.models.dms._rules import (
             DMSContainer,
             DMSProperty,
@@ -957,6 +1041,13 @@ class _InformationRulesConverter:
                 continue
             if prop.class_ in edge_classes and prop.property_ in self._start_or_end_node:
                 continue
+            if prop.property_ in DMS_RESERVED_PROPERTIES:
+                msg = f"Property {prop.property_} is a reserved property in DMS."
+                if reserved_properties == "error":
+                    raise NeatValueError(msg)
+                warnings.warn(NeatValueWarning(f"{msg} Skipping..."), stacklevel=2)
+                continue
+
             dms_property = self._as_dms_property(
                 prop,
                 default_space,