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

cognite/neat/_rules/analysis/_information.py

@@ -55,12 +55,13 @@ class InformationAnalysis(BaseAnalysis[InformationRules, InformationClass, Infor
 
     def has_hop_transformations(self):
         return any(
-            prop_.transformation and isinstance(prop_.transformation.traversal, Hop) for prop_ in self.rules.properties
+            prop_.instance_source and isinstance(prop_.instance_source.traversal, Hop)
+            for prop_ in self.rules.properties
         )
 
     def has_self_reference_property_transformations(self):
         return any(
-            prop_.transformation and isinstance(prop_.transformation.traversal, SelfReferenceProperty)
+            prop_.instance_source and isinstance(prop_.instance_source.traversal, SelfReferenceProperty)
             for prop_ in self.rules.properties
         )
 
@@ -68,7 +69,7 @@ class InformationAnalysis(BaseAnalysis[InformationRules, InformationClass, Infor
         return [
             prop_
             for prop_ in self.rules.properties
-            if prop_.transformation and isinstance(prop_.transformation.traversal, SelfReferenceProperty)
+            if prop_.instance_source and isinstance(prop_.instance_source.traversal, SelfReferenceProperty)
         ]
 
     def define_property_renaming_config(self, class_: ClassEntity) -> dict[str | URIRef, str]:
@@ -76,7 +77,7 @@ class InformationAnalysis(BaseAnalysis[InformationRules, InformationClass, Infor
 
         if definitions := self.class_property_pairs(only_rdfpath=True, consider_inheritance=True).get(class_, None):
             for property_id, definition in definitions.items():
-                transformation = cast(RDFPath, definition.transformation)
+                transformation = cast(RDFPath, definition.instance_source)
 
                 # use case we have a single property rdf path, and defined prefix
                 # in either metadata or prefixes of rules
@@ -101,26 +102,26 @@ class InformationAnalysis(BaseAnalysis[InformationRules, InformationClass, Infor
 
         return property_renaming_configuration
 
-    def neat_id_to_transformation_property_uri(self, property_neat_id: URIRef) -> URIRef | None:
+    def neat_id_to_instance_source_property_uri(self, property_neat_id: URIRef) -> URIRef | None:
         if (
             (property_ := self.properties_by_neat_id.get(property_neat_id))
-            and property_.transformation
+            and property_.instance_source
             and isinstance(
-                property_.transformation.traversal,
+                property_.instance_source.traversal,
                 SingleProperty,
             )
             and (
-                property_.transformation.traversal.property.prefix in self.rules.prefixes
-                or property_.transformation.traversal.property.prefix == self.rules.metadata.prefix
+                property_.instance_source.traversal.property.prefix in self.rules.prefixes
+                or property_.instance_source.traversal.property.prefix == self.rules.metadata.prefix
             )
         ):
             namespace = (
                 self.rules.metadata.namespace
-                if property_.transformation.traversal.property.prefix == self.rules.metadata.prefix
-                else self.rules.prefixes[property_.transformation.traversal.property.prefix]
+                if property_.instance_source.traversal.property.prefix == self.rules.metadata.prefix
+                else self.rules.prefixes[property_.instance_source.traversal.property.prefix]
             )
 
-            return namespace[property_.transformation.traversal.property.suffix]
+            return namespace[property_.instance_source.traversal.property.suffix]
         return None
 
     def property_types(self, class_: ClassEntity) -> dict[str, EntityTypes]:
@@ -137,7 +138,7 @@ class InformationAnalysis(BaseAnalysis[InformationRules, InformationClass, Infor
             class_, None
         ):
             for property_ in class_property_pairs.values():
-                classes.append(cast(RDFPath, property_.transformation).traversal.class_)
+                classes.append(cast(RDFPath, property_.instance_source).traversal.class_)
 
             return cast(ClassEntity, most_occurring_element(classes))
         else:

cognite/neat/_rules/catalog/__init__.py

@@ -5,3 +5,4 @@ from pathlib import Path
 _CATALOG = Path(__file__).parent
 imf_attributes = _CATALOG / "info-rules-imf.xlsx"
 hello_world_pump = _CATALOG / "hello_world_pump.xlsx"
+classic_model = _CATALOG / "classic_model.xlsx"

cognite/neat/_rules/importers/_dms2rules.py

@@ -115,8 +115,8 @@ class DMSImporter(BaseImporter[DMSInputRules]):
         data_model_ids = [data_model_id]
         data_models = client.data_modeling.data_models.retrieve(data_model_ids, inline_views=True)
 
-        user_models = cls._find_model_in_list(data_models, data_model_id)
-        if len(user_models) == 0:
+        retrieved_models = cls._find_model_in_list(data_models, data_model_id)
+        if len(retrieved_models) == 0:
             return cls(
                 DMSSchema(),
                 [
@@ -127,16 +127,18 @@ class DMSImporter(BaseImporter[DMSInputRules]):
                     )
                 ],
             )
-        user_model = user_models.latest_version()
+        return cls.from_data_model(client, retrieved_models.latest_version())
 
+    @classmethod
+    def from_data_model(cls, client: NeatClient, model: dm.DataModel[dm.View]) -> "DMSImporter":
         issue_list = IssueList()
         with _handle_issues(issue_list) as result:
-            schema = NeatClient(client).schema.retrieve_data_model(user_model)
+            schema = client.schema.retrieve_data_model(model)
 
         if result.result == "failure" or issue_list.has_errors:
             return cls(DMSSchema(), issue_list)
 
-        metadata = cls._create_metadata_from_model(user_model)
+        metadata = cls._create_metadata_from_model(model)
 
         return cls(
             schema,

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

@@ -233,7 +233,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)})"
                         ),

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
@@ -31,7 +30,6 @@ from pydantic import (
     PlainSerializer,
     field_validator,
     model_serializer,
-    model_validator,
 )
 from pydantic.main import IncEx
 from pydantic_core import core_schema
@@ -343,10 +341,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 +348,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"
 
 
@@ -442,6 +445,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/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

@@ -79,7 +79,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,6 +1,8 @@
 from ._base import RulesTransformer
 from ._converters import (
     AddClassImplements,
+    ChangeViewPrefix,
+    ClassicPrepareCore,
     ConvertToRules,
     DMSToInformation,
     IncludeReferenced,
@@ -20,6 +22,8 @@ from ._verification import VerifyAnyRules, VerifyDMSRules, VerifyInformationRule
 __all__ = [
     "AddClassImplements",
     "AsParentPropertyId",
+    "ChangeViewPrefix",
+    "ClassicPrepareCore",
     "ConvertToRules",
     "DMSToInformation",
     "IncludeReferenced",