cognite-neat 0.85.10__tar.gz → 0.85.12__tar.gz

{cognite_neat-0.85.10 → cognite_neat-0.85.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cognite-neat
-Version: 0.85.10
+Version: 0.85.12
 Summary: Knowledge graph transformation
 Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0

cognite_neat-0.85.12/cognite/neat/_version.py

@@ -0,0 +1 @@
+__version__ = "0.85.12"

{cognite_neat-0.85.10 → cognite_neat-0.85.12}/cognite/neat/graph/loaders/_rdf2dms.py

@@ -2,7 +2,7 @@ import json
 from collections import defaultdict
 from collections.abc import Iterable, Sequence
 from pathlib import Path
-from typing import Any
+from typing import Any, get_args
 
 import yaml
 from cognite.client import CogniteClient
@@ -20,7 +20,7 @@ from cognite.neat.graph.issues import loader as loader_issues
 from cognite.neat.graph.stores import NeatGraphStore
 from cognite.neat.issues import NeatIssue, NeatIssueList
 from cognite.neat.rules.models import DMSRules
-from cognite.neat.rules.models.data_types import _DATA_TYPE_BY_DMS_TYPE
+from cognite.neat.rules.models.data_types import _DATA_TYPE_BY_DMS_TYPE, Json
 from cognite.neat.utils.upload import UploadResult
 from cognite.neat.utils.utils import create_sha256_hash
 
@@ -145,7 +145,9 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         issues = NeatIssueList[NeatIssue]()
         field_definitions: dict[str, tuple[type, Any]] = {}
         edge_by_property: dict[str, dm.EdgeConnection] = {}
+        validators: dict[str, classmethod] = {}
         direct_relation_by_property: dict[str, dm.DirectRelation] = {}
+        json_fields: list[str] = []
         for prop_name, prop in view.properties.items():
             if isinstance(prop, dm.EdgeConnection):
                 edge_by_property[prop_name] = prop
@@ -163,6 +165,9 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
                             )
                         )
                         continue
+
+                    if data_type == Json:
+                        json_fields.append(prop_name)
                     python_type = data_type.python
                 if prop.type.is_list:
                     python_type = list[python_type]
@@ -175,13 +180,29 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
                 field_definitions[prop_name] = (python_type, default_value)
 
         def parse_list(cls, value: Any, info: ValidationInfo) -> list[str]:
-            if isinstance(value, list) and cls.model_fields[info.field_name].annotation is not list:
+            if isinstance(value, list) and list.__name__ not in _get_field_value_types(cls, info):
                 if len(value) == 1:
                     return value[0]
                 raise ValueError(f"Got multiple values for {info.field_name}: {value}")
+
             return value
 
-        validators: dict[str, classmethod] = {"parse_list": field_validator("*", mode="before")(parse_list)}  # type: ignore[dict-item,arg-type]
+        def parse_json_string(cls, value: Any, info: ValidationInfo) -> dict:
+            if isinstance(value, dict):
+                return value
+            elif isinstance(value, str):
+                try:
+                    return json.loads(value)
+                except json.JSONDecodeError as error:
+                    raise ValueError(f"Not valid JSON string for {info.field_name}: {value}, error {error}") from error
+            else:
+                raise ValueError(f"Expect valid JSON string or dict for {info.field_name}: {value}")
+
+        if json_fields:
+            validators["parse_json_string"] = field_validator(*json_fields, mode="before")(parse_json_string)  # type: ignore[assignment, arg-type]
+
+        validators["parse_list"] = field_validator("*", mode="before")(parse_list)  # type: ignore[assignment, arg-type]
+
         if direct_relation_by_property:
 
             def parse_direct_relation(cls, value: list, info: ValidationInfo) -> dict | list[dict]:
@@ -280,7 +301,10 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             result.created.update(item.as_id() for item in e.successful)
             yield result
         else:
-            for instance_type, instances in {"Nodes": upserted.nodes, "Edges": upserted.edges}.items():
+            for instance_type, instances in {
+                "Nodes": upserted.nodes,
+                "Edges": upserted.edges,
+            }.items():
                 result = UploadResult[InstanceId](name=instance_type, issues=read_issues)
                 for instance in instances:  # type: ignore[attr-defined]
                     if instance.was_modified and instance.created_time == instance.last_updated_time:
@@ -292,6 +316,10 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
                 yield result
 
 
+def _get_field_value_types(cls, info):
+    return [type_.__name__ for type_ in get_args(cls.model_fields[info.field_name].annotation)]
+
+
 def _triples2dictionary(
     triples: Iterable[tuple[str, str, str]],
 ) -> dict[str, dict[str, list[str]]]:

{cognite_neat-0.85.10 → cognite_neat-0.85.12}/cognite/neat/rules/importers/_inference2rules.py

@@ -75,7 +75,9 @@ class InferenceImporter(BaseImporter):
         self.graph = graph
         self.max_number_of_instance = max_number_of_instance
         self.prefix = prefix
-        self.check_for_json_string = check_for_json_string
+        self.check_for_json_string = (
+            check_for_json_string if graph.store.__class__.__name__ != "OxigraphStore" else False
+        )
 
     @classmethod
     def from_graph_store(
@@ -235,6 +237,7 @@ class InferenceImporter(BaseImporter):
                     query.replace("instance_id", instance)
                 ):  # type: ignore[misc]
                     property_id = remove_namespace_from_uri(property_uri)
+
                     self._add_uri_namespace_to_prefixes(cast(URIRef, property_uri), prefixes)
                     value_type_uri = data_type_uri if data_type_uri else object_type_uri
 

{cognite_neat-0.85.10 → cognite_neat-0.85.12}/cognite/neat/rules/models/data_types.py

@@ -237,7 +237,7 @@ class Literal(DataType):
 
 class Timeseries(DataType):
     name = "timeseries"
-    python = dms.TimeSeriesReference
+    python = str
     dms = dms.TimeSeriesReference
     graphql = "TimeSeries"
     xsd = "string"
@@ -246,7 +246,7 @@ class Timeseries(DataType):
 
 class File(DataType):
     name = "file"
-    python = dms.FileReference
+    python = str
     dms = dms.FileReference
     graphql = "File"
     xsd = "string"
@@ -255,7 +255,7 @@ class File(DataType):
 
 class Sequence(DataType):
     name = "sequence"
-    python = dms.SequenceReference
+    python = str
     dms = dms.SequenceReference
     graphql = "Sequence"
     xsd = "string"
@@ -264,7 +264,7 @@ class Sequence(DataType):
 
 class Json(DataType):
     name = "json"
-    python = dms.Json
+    python = dict
     dms = dms.Json
     graphql = "Json"
     xsd = "json"

{cognite_neat-0.85.10 → cognite_neat-0.85.12}/cognite/neat/rules/models/dms/_rules.py

@@ -2,6 +2,7 @@ import math
 import re
 import sys
 import warnings
+from collections import defaultdict
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, ClassVar, Literal
 
@@ -390,3 +391,72 @@ class DMSRules(BaseRules):
         from ._converter import _DMSRulesConverter
 
         return _DMSRulesConverter(self).as_domain_rules()
+
+    def create_reference(
+        self, reference: "DMSRules", view_extension_mapping: dict[str, str], default_extension: str | None = None
+    ) -> None:
+        """Takes this data models and makes it into an extension of the reference data model.
+
+        The argument view_extension_mapping is a dictionary where the keys are views of this data model,
+        and each value is the view of the reference data model that the view should extend. For example:
+
+        ```python
+        view_extension_mapping = {"Pump": "Asset"}
+        ```
+
+        This would make the view "Pump" in this data model extend the view "Asset" in the reference data model.
+        Note that all the keys in the dictionary must be external ids of views in this data model,
+        and all the values must be external ids of views in the reference data model.
+
+        Args:
+            reference: The reference data model
+            view_extension_mapping: A dictionary mapping views in this data model to views in the reference data model
+            default_extension: The default view in the reference data model that views in this
+                data model should extend if no mapping is provided.
+
+        """
+        if self.reference is not None:
+            raise ValueError("Reference already exists")
+        self.reference = reference
+        view_by_external_id = {view.view.external_id: view for view in self.views}
+        ref_view_by_external_id = {view.view.external_id: view for view in reference.views}
+
+        if invalid_views := set(view_extension_mapping.keys()) - set(view_by_external_id.keys()):
+            raise ValueError(f"Views are not in this dat model {invalid_views}")
+        if invalid_views := set(view_extension_mapping.values()) - set(ref_view_by_external_id.keys()):
+            raise ValueError(f"Views are not in the reference data model {invalid_views}")
+        if default_extension and default_extension not in ref_view_by_external_id:
+            raise ValueError(f"Default extension view not in the reference data model {default_extension}")
+
+        properties_by_view_external_id: dict[str, dict[str, DMSProperty]] = defaultdict(dict)
+        for prop in self.properties:
+            properties_by_view_external_id[prop.view.external_id][prop.view_property] = prop
+
+        ref_properties_by_view_external_id: dict[str, dict[str, DMSProperty]] = defaultdict(dict)
+        for prop in reference.properties:
+            ref_properties_by_view_external_id[prop.view.external_id][prop.view_property] = prop
+
+        for view_external_id, view in view_by_external_id.items():
+            if view_external_id in view_extension_mapping:
+                ref_external_id = view_extension_mapping[view_external_id]
+            elif default_extension:
+                ref_external_id = default_extension
+            else:
+                continue
+
+            ref_view = ref_view_by_external_id[ref_external_id]
+            shared_properties = set(properties_by_view_external_id[view_external_id].keys()) & set(
+                ref_properties_by_view_external_id[ref_external_id].keys()
+            )
+            if shared_properties:
+                if view.implements is None:
+                    view.implements = [ref_view.view]
+                elif isinstance(view.implements, list) and ref_view.view not in view.implements:
+                    view.implements.append(ref_view.view)
+            for prop_name in shared_properties:
+                prop = properties_by_view_external_id[view_external_id][prop_name]
+                ref_prop = ref_properties_by_view_external_id[ref_external_id][prop_name]
+                if ref_prop.container and ref_prop.container_property:
+                    prop.container = ref_prop.container
+                    prop.container_property = ref_prop.container_property
+                prop.reference = ReferenceEntity.from_entity(ref_prop.view, ref_prop.view_property)

{cognite_neat-0.85.10 → cognite_neat-0.85.12}/cognite/neat/rules/models/dms/_rules_input.py

@@ -146,7 +146,9 @@ class DMSPropertyInput:
             "Value Type": value_type,
             "Property (linage)": self.property_ or self.view_property,
             "Class (linage)": (
-                ClassEntity.load(self.class_, prefix=default_space, version=default_version) if self.class_ else None
+                ClassEntity.load(self.class_ or self.view, prefix=default_space, version=default_version)
+                if self.class_ or self.view
+                else None
             ),
             "Name": self.name,
             "Description": self.description,

{cognite_neat-0.85.10 → cognite_neat-0.85.12}/cognite/neat/rules/models/entities.py

@@ -499,6 +499,13 @@ class ReferenceEntity(ClassEntity):
     prefix: str
     property_: str | None = Field(None, alias="property")
 
+    @classmethod
+    def from_entity(cls, entity: Entity, property_: str) -> "ReferenceEntity":
+        if isinstance(entity, ClassEntity):
+            return cls(prefix=str(entity.prefix), suffix=entity.suffix, version=entity.version, property=property_)
+        else:
+            return cls(prefix=str(entity.prefix), suffix=entity.suffix, property=property_)
+
     def as_view_id(self) -> ViewId:
         if isinstance(self.prefix, _UndefinedType) or isinstance(self.suffix, _UnknownType):
             raise ValueError("Prefix is not defined or suffix is unknown")

{cognite_neat-0.85.10 → cognite_neat-0.85.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cognite-neat"
-version = "0.85.10"
+version = "0.85.12"
 readme = "README.md"
 description = "Knowledge graph transformation"
 authors = [

cognite_neat-0.85.10/cognite/neat/_version.py

@@ -1 +0,0 @@
-__version__ = "0.85.10"