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

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):
@@ -233,7 +228,7 @@ class InferenceImporter(BaseRDFImporter):
                         "property_": property_id,
                         "max_count": cast(RdfLiteral, occurrence).value,
                         "value_type": value_type_id,
-                        "transformation": (
+                        "instance_source": (
                             f"{uri_to_short_form(class_definition['uri'], prefixes)}"
                             f"({uri_to_short_form(cast(URIRef, property_uri), prefixes)})"
                         ),
@@ -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

@@ -5,7 +5,6 @@ its sub-models and validators.
 import math
 import sys
 import types
-import uuid
 from abc import ABC, abstractmethod
 from collections.abc import Callable, Hashable, Iterator, MutableSequence, Sequence
 from datetime import datetime
@@ -22,6 +21,7 @@ from typing import (
 )
 
 import pandas as pd
+from cognite.client import data_modeling as dm
 from pydantic import (
     BaseModel,
     BeforeValidator,
@@ -31,7 +31,6 @@ from pydantic import (
     PlainSerializer,
     field_validator,
     model_serializer,
-    model_validator,
 )
 from pydantic.main import IncEx
 from pydantic_core import core_schema
@@ -182,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):
@@ -215,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
 
@@ -236,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):
     """
@@ -343,10 +351,6 @@ class BaseRules(SchemaModel, ABC):
         return output
 
 
-def make_neat_id() -> URIRef:
-    return DEFAULT_NAMESPACE[f"neatId_{str(uuid.uuid4()).replace('-', '_')}"]
-
-
 class SheetRow(SchemaModel):
     neatId: URIRefType | None = Field(
         alias="Neat ID",
@@ -354,12 +358,6 @@ class SheetRow(SchemaModel):
         default=None,
     )
 
-    @model_validator(mode="after")
-    def set_neat_id(self) -> "SheetRow":
-        if self.neatId is None:
-            self.neatId = DEFAULT_NAMESPACE[f"neatId_{str(uuid.uuid4()).replace('-', '_')}"]
-        return self
-
     @abstractmethod
     def _identifier(self) -> tuple[Hashable, ...]:
         raise NotImplementedError()

cognite/neat/_rules/models/_types.py

@@ -76,6 +76,11 @@ NamespaceType = Annotated[
 URIRefType = Annotated[
     rdflib.URIRef,
     BeforeValidator(lambda value: rdflib.URIRef(value)),
+    PlainSerializer(
+        lambda value: str(value),
+        return_type=str,
+        when_used="unless-none",
+    ),
 ]
 
 PrefixType = Annotated[

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

@@ -1,10 +1,10 @@
 import warnings
 from collections.abc import Hashable
-from typing import Any, ClassVar, Literal
+from typing import TYPE_CHECKING, Any, ClassVar, Literal
 
 import pandas as pd
 from cognite.client import data_modeling as dm
-from pydantic import Field, field_serializer, field_validator
+from pydantic import Field, field_serializer, field_validator, model_validator
 from pydantic_core.core_schema import SerializationInfo, ValidationInfo
 
 from cognite.neat._client.data_classes.schema import DMSSchema
@@ -48,6 +48,9 @@ from cognite.neat._rules.models.entities import (
     ViewEntityList,
 )
 
+if TYPE_CHECKING:
+    from cognite.neat._rules.models import InformationRules
+
 _DEFAULT_VERSION = "1"
 
 
@@ -61,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:
@@ -80,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
 
@@ -106,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,
@@ -442,6 +438,51 @@ class DMSRules(BaseRules):
                 )
         return value
 
+    @model_validator(mode="after")
+    def set_neat_id(self) -> "DMSRules":
+        namespace = self.metadata.namespace
+
+        for view in self.views:
+            if not view.neatId:
+                view.neatId = namespace[view.view.suffix]
+
+        for property_ in self.properties:
+            if not property_.neatId:
+                property_.neatId = namespace[f"{property_.view.suffix}/{property_.view_property}"]
+
+        return self
+
+    def update_neat_id(self) -> None:
+        """Update neat ids"""
+
+        namespace = self.metadata.namespace
+
+        for view in self.views:
+            view.neatId = namespace[view.view.suffix]
+
+        for property_ in self.properties:
+            property_.neatId = namespace[f"{property_.view.suffix}/{property_.view_property}"]
+
+    def sync_with_info_rules(self, info_rules: "InformationRules") -> None:
+        # Sync at the metadata level
+        if info_rules.metadata.physical == self.metadata.identifier:
+            self.metadata.logical = info_rules.metadata.identifier
+        else:
+            # if models are not linked to start with, we skip
+            return None
+
+        info_properties_by_neat_id = {prop.neatId: prop for prop in info_rules.properties}
+        dms_properties_by_neat_id = {prop.neatId: prop for prop in self.properties}
+        for neat_id, prop in info_properties_by_neat_id.items():
+            if prop.physical in dms_properties_by_neat_id:
+                dms_properties_by_neat_id[prop.physical].logical = neat_id
+
+        info_classes_by_neat_id = {cls.neatId: cls for cls in info_rules.classes}
+        dms_views_by_neat_id = {view.neatId: view for view in self.views}
+        for neat_id, class_ in info_classes_by_neat_id.items():
+            if class_.physical in dms_views_by_neat_id:
+                dms_views_by_neat_id[class_.physical].logical = neat_id
+
     def as_schema(self, instance_space: str | None = None, remove_cdf_spaces: bool = False) -> DMSSchema:
         from ._exporter import _DMSExporter
 

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.py

@@ -121,7 +121,7 @@ class InformationProperty(SheetRow):
         min_count: Minimum count of the property values. Defaults to 0
         max_count: Maximum count of the property values. Defaults to None
         default: Default value of the property
-        transformation: Actual rule for the transformation from source to target representation of
+        instance_source: Actual rule for the transformation from source to target representation of
               knowledge graph. Defaults to None (no transformation)
     """
 
@@ -153,10 +153,10 @@ class InformationProperty(SheetRow):
         "which means that the property can hold any number of values (listable).",
     )
     default: Any | None = Field(alias="Default", default=None, description="Default value of the property.")
-    transformation: RDFPath | None = Field(
-        alias="Transformation",
+    instance_source: RDFPath | None = Field(
+        alias="Instance Source",
         default=None,
-        description="The rule that is used to populate the data model. "
+        description="The link to to the instance property for the model. "
         "The rule is provided in a RDFPath query syntax which is converted to downstream solution query (e.g. SPARQL).",
     )
     inherited: bool = Field(
@@ -181,7 +181,7 @@ class InformationProperty(SheetRow):
             return float("inf")
         return value
 
-    @field_validator("transformation", mode="before")
+    @field_validator("instance_source", mode="before")
     def generate_rdfpath(cls, value: str | RDFPath | None) -> RDFPath | None:
         if value is None or isinstance(value, RDFPath):
             return value
@@ -267,6 +267,49 @@ class InformationRules(BaseRules):
             values = get_default_prefixes_and_namespaces()
         return values
 
+    @model_validator(mode="after")
+    def set_neat_id(self) -> "InformationRules":
+        namespace = self.metadata.namespace
+
+        for class_ in self.classes:
+            if not class_.neatId:
+                class_.neatId = namespace[class_.class_.suffix]
+        for property_ in self.properties:
+            if not property_.neatId:
+                property_.neatId = namespace[f"{property_.class_.suffix}/{property_.property_}"]
+
+        return self
+
+    def update_neat_id(self) -> None:
+        """Update neat ids"""
+
+        namespace = self.metadata.namespace
+
+        for class_ in self.classes:
+            class_.neatId = namespace[class_.class_.suffix]
+        for property_ in self.properties:
+            property_.neatId = namespace[f"{property_.class_.suffix}/{property_.property_}"]
+
+    def sync_with_dms_rules(self, dms_rules: "DMSRules") -> None:
+        # Sync at the metadata level
+        if dms_rules.metadata.logical == self.metadata.identifier:
+            self.metadata.physical = dms_rules.metadata.identifier
+        else:
+            # if models are not linked to start with, we skip
+            return None
+
+        info_properties_by_neat_id = {prop.neatId: prop for prop in self.properties}
+        dms_properties_by_neat_id = {prop.neatId: prop for prop in dms_rules.properties}
+        for neat_id, prop in dms_properties_by_neat_id.items():
+            if prop.logical in info_properties_by_neat_id:
+                info_properties_by_neat_id[prop.logical].physical = neat_id
+
+        info_classes_by_neat_id = {cls.neatId: cls for cls in self.classes}
+        dms_views_by_neat_id = {view.neatId: view for view in dms_rules.views}
+        for neat_id, view in dms_views_by_neat_id.items():
+            if view.logical in info_classes_by_neat_id:
+                info_classes_by_neat_id[view.logical].physical = neat_id
+
     def as_dms_rules(self) -> "DMSRules":
         from cognite.neat._rules.transformers._converters import _InformationRulesConverter
 

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
@@ -79,7 +84,7 @@ class InformationInputProperty(InputComponent[InformationProperty]):
     min_count: int | None = None
     max_count: int | float | None = None
     default: Any | None = None
-    transformation: str | None = None
+    instance_source: str | None = None
     # Only used internally
     inherited: bool = False
     neatId: str | URIRef | None = None

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

@@ -15,14 +15,13 @@ def _read_source_file() -> str:
     return _CLASSIC_TO_CORE_MAPPING.read_text()
 
 
-def load_classic_to_core_mapping(org_name: str, source_space: str, source_version: str) -> DMSRules:
-    if not org_name:
-        raise NeatValueError("Organization name must be provided.")
-
+def load_classic_to_core_mapping(org_name: str | None, source_space: str, source_version: str) -> DMSRules:
     from cognite.neat._rules.importers import YAMLImporter
     from cognite.neat._rules.transformers import VerifyDMSRules
 
-    raw_str = _read_source_file().replace("Classic", org_name)
+    raw_str = _read_source_file()
+    if org_name is not None:
+        raw_str = raw_str.replace("Classic", org_name)
 
     loaded = yaml.safe_load(raw_str)
     loaded["metadata"]["space"] = source_space

cognite/neat/_rules/transformers/__init__.py

@@ -1,10 +1,15 @@
 from ._base import RulesTransformer
 from ._converters import (
     AddClassImplements,
+    ChangeViewPrefix,
+    ClassicPrepareCore,
+    ConversionTransformer,
     ConvertToRules,
     DMSToInformation,
     IncludeReferenced,
     InformationToDMS,
+    MergeDMSRules,
+    MergeInformationRules,
     PrefixEntities,
     ReduceCogniteModel,
     SetIDDMSModel,
@@ -20,11 +25,16 @@ from ._verification import VerifyAnyRules, VerifyDMSRules, VerifyInformationRule
 __all__ = [
     "AddClassImplements",
     "AsParentPropertyId",
+    "ChangeViewPrefix",
+    "ClassicPrepareCore",
+    "ConversionTransformer",
     "ConvertToRules",
     "DMSToInformation",
     "IncludeReferenced",
     "InformationToDMS",
     "MapOneToOne",
+    "MergeDMSRules",
+    "MergeInformationRules",
     "PrefixEntities",
     "ReduceCogniteModel",
     "RuleMapper",