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

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