cognite-neat 0.109.4__tar.gz → 0.110.0__tar.gz

{cognite_neat-0.109.4 → cognite_neat-0.110.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cognite-neat
-Version: 0.109.4
+Version: 0.110.0
 Summary: Knowledge graph transformation
 License: Apache-2.0
 Author: Nikola Vasiljevic

{cognite_neat-0.109.4 → cognite_neat-0.110.0}/cognite/neat/_alpha.py

@@ -13,3 +13,5 @@ class AlphaFlags:
     manual_rules_edit = AlphaWarning("enable_manual_edit")
     same_space_properties_only_export = AlphaWarning("same-space-properties-only")
     standardize_naming = AlphaWarning("standardize_naming")
+    standardize_space_and_version = AlphaWarning("standardize_space_and_version")
+    data_model_subsetting = AlphaWarning("data_model_subsetting")

{cognite_neat-0.109.4 → cognite_neat-0.110.0}/cognite/neat/_client/_api/schema.py

@@ -1,10 +1,12 @@
-from collections.abc import Sequence
+from collections import defaultdict
+from collections.abc import Iterable, Sequence
 from typing import TYPE_CHECKING
 
 from cognite.client import data_modeling as dm
 
 from cognite.neat._client.data_classes.data_modeling import ContainerApplyDict, SpaceApplyDict, ViewApplyDict
 from cognite.neat._client.data_classes.schema import DMSSchema
+from cognite.neat._constants import is_hierarchy_property
 from cognite.neat._issues.errors import NeatValueError
 
 if TYPE_CHECKING:
@@ -110,3 +112,17 @@ class SchemaAPI:
             views=view_write,
             containers=container_write,
         )
+
+    @staticmethod
+    def get_hierarchical_properties(
+        views: Iterable[dm.View | dm.ViewApply],
+    ) -> dict[dm.ViewId, set[str]]:
+        """Sorts the views by container constraints."""
+        hierarchical_properties_by_view_id: dict[dm.ViewId, set[str]] = defaultdict(set)
+        for view in views:
+            for prop_id, prop in (view.properties or {}).items():
+                if not isinstance(prop, dm.MappedProperty | dm.MappedPropertyApply):
+                    continue
+                if is_hierarchy_property(prop.container, prop.container_property_identifier):
+                    hierarchical_properties_by_view_id[view.as_id()].add(prop_id)
+        return hierarchical_properties_by_view_id

{cognite_neat-0.109.4 → cognite_neat-0.110.0}/cognite/neat/_client/data_classes/schema.py

@@ -34,7 +34,7 @@ from cognite.neat._issues.warnings import (
     FileTypeUnexpectedWarning,
     ResourcesDuplicatedWarning,
 )
-from cognite.neat._utils.text import to_camel
+from cognite.neat._utils.text import to_camel_case
 
 if sys.version_info >= (3, 11):
     from typing import Self
@@ -238,7 +238,7 @@ class DMSSchema:
             data_dict = data
         loaded: dict[str, Any] = {}
         for attr in fields(cls):
-            if items := data_dict.get(attr.name) or data_dict.get(to_camel(attr.name)):
+            if items := data_dict.get(attr.name) or data_dict.get(to_camel_case(attr.name)):
                 if attr.name == "data_model":
                     if isinstance(items, list) and len(items) > 1:
                         try:
@@ -320,7 +320,7 @@ class DMSSchema:
         cls_fields = sorted(fields(self), key=lambda f: f.name) if sort else fields(self)
         for attr in cls_fields:
             if items := getattr(self, attr.name):
-                key = to_camel(attr.name) if camel_case else attr.name
+                key = to_camel_case(attr.name) if camel_case else attr.name
                 if isinstance(items, CogniteResourceDict):
                     if sort:
                         output[key] = [

{cognite_neat-0.109.4 → cognite_neat-0.110.0}/cognite/neat/_constants.py

@@ -164,11 +164,22 @@ READONLY_PROPERTIES_BY_CONTAINER: Mapping[dm.ContainerId, frozenset[str]] = {
     dm.ContainerId("cdf_cdm", "CogniteFile"): frozenset({"isUploaded", "uploadedTime"}),
 }
 
+HIERARCHICAL_PROPERTIES_BY_CONTAINER: Mapping[dm.ContainerId, frozenset[str]] = {
+    dm.ContainerId("cdf_cdm", "CogniteAsset"): frozenset({"assetHierarchy_parent"})
+}
+
 
 def is_readonly_property(container: dm.ContainerId, property_: str) -> bool:
     return container in READONLY_PROPERTIES_BY_CONTAINER and property_ in READONLY_PROPERTIES_BY_CONTAINER[container]
 
 
+def is_hierarchy_property(container: dm.ContainerId, property_: str) -> bool:
+    return (
+        container in HIERARCHICAL_PROPERTIES_BY_CONTAINER
+        and property_ in HIERARCHICAL_PROPERTIES_BY_CONTAINER[container]
+    )
+
+
 DMS_RESERVED_PROPERTIES = frozenset(
     {
         "createdTime",

{cognite_neat-0.109.4 → cognite_neat-0.110.0}/cognite/neat/_graph/extractors/_classic_cdf/_classic.py

@@ -16,12 +16,10 @@ from cognite.neat._issues.warnings import CDFAuthWarning, NeatValueWarning
 from cognite.neat._rules._shared import ReadRules
 from cognite.neat._rules.catalog import classic_model
 from cognite.neat._rules.models import InformationInputRules, InformationRules
-from cognite.neat._rules.models._rdfpath import Entity as RDFPathEntity
-from cognite.neat._rules.models._rdfpath import RDFPath, SingleProperty
 from cognite.neat._shared import Triple
 from cognite.neat._utils.collection_ import chunker, iterate_progress_bar
 from cognite.neat._utils.rdf_ import remove_namespace_from_uri
-from cognite.neat._utils.text import to_snake
+from cognite.neat._utils.text import to_snake_case
 
 from ._assets import AssetsExtractor
 from ._base import ClassicCDFBaseExtractor, InstanceIdPrefix
@@ -194,13 +192,14 @@ class ClassicGraphExtractor(KnowledgeGraphExtractor):
         for prop in verified.properties:
             prop_id = prop.property_
             if is_snake_case:
-                prop_id = to_snake(prop_id)
-            prop.instance_source = RDFPath(
-                traversal=SingleProperty(
-                    class_=RDFPathEntity(prefix=instance_prefix, suffix=prop.class_.suffix),
-                    property=RDFPathEntity(prefix=instance_prefix, suffix=prop_id),
-                )
-            )
+                prop_id = to_snake_case(prop_id)
+            prop.instance_source = [self._namespace[prop_id]]
+        for cls_ in verified.classes:
+            cls_id = cls_.class_.suffix
+            if is_snake_case:
+                cls_id = to_snake_case(cls_id)
+            cls_.instance_source = self._namespace[cls_id]
+
         return verified
 
     @property

{cognite_neat-0.109.4 → cognite_neat-0.110.0}/cognite/neat/_graph/extractors/_iodd.py

@@ -14,7 +14,7 @@ from cognite.neat._graph.extractors._base import BaseExtractor
 from cognite.neat._issues.errors import FileReadError, NeatValueError
 from cognite.neat._shared import Triple
 from cognite.neat._utils.rdf_ import remove_namespace_from_uri
-from cognite.neat._utils.text import to_camel
+from cognite.neat._utils.text import to_camel_case
 from cognite.neat._utils.xml_ import get_children
 
 IODD = Namespace("http://www.io-link.com/IODD/2010/10/")
@@ -170,7 +170,7 @@ class IODDExtractor(BaseExtractor):
             ):
                 if text_id := child[0].attrib.get("textId"):
                     # Create connection from device to textId node
-                    element_tag = to_camel(element_tag)
+                    element_tag = to_camel_case(element_tag)
                     triples.append((id, IODD[element_tag], namespace[text_id]))
 
         return triples
@@ -216,7 +216,7 @@ class IODDExtractor(BaseExtractor):
                 if id := element.attrib.get("id"):
                     if id in cls.std_variable_elements_to_extract:
                         if object := element.attrib.get("defaultValue"):
-                            predicate = to_camel(id.replace("V_", ""))
+                            predicate = to_camel_case(id.replace("V_", ""))
                             triples.append((device_id, IODD[predicate], Literal(object)))
         return triples
 

{cognite_neat-0.109.4 → cognite_neat-0.110.0}/cognite/neat/_graph/extractors/_mock_graph_generator.py

@@ -12,11 +12,12 @@ import pandas as pd
 from rdflib import RDF, Literal, Namespace, URIRef
 
 from cognite.neat._rules._constants import EntityTypes
-from cognite.neat._rules.analysis import InformationAnalysis
+from cognite.neat._rules.analysis import RulesAnalysis
 from cognite.neat._rules.models import DMSRules, InformationRules
 from cognite.neat._rules.models.data_types import DataType
 from cognite.neat._rules.models.entities import ClassEntity
 from cognite.neat._rules.models.information import InformationProperty
+from cognite.neat._rules.transformers import SubsetInformationRules
 from cognite.neat._shared import Triple
 from cognite.neat._utils.rdf_ import remove_namespace_from_uri
 
@@ -54,7 +55,7 @@ class MockGraphGenerator(BaseExtractor):
 
         if not class_count:
             self.class_count = {
-                class_: 1 for class_ in InformationAnalysis(self.rules).defined_classes(consider_inheritance=True)
+                class_: 1 for class_ in RulesAnalysis(self.rules).defined_classes(include_ancestors=True)
             }
         elif all(isinstance(key, str) for key in class_count.keys()):
             self.class_count = {
@@ -104,7 +105,8 @@ def generate_triples(
     """
 
     namespace = rules.metadata.namespace
-    defined_classes = InformationAnalysis(rules).defined_classes(consider_inheritance=True)
+    analysis = RulesAnalysis(rules)
+    defined_classes = analysis.defined_classes(include_ancestors=True)
 
     if non_existing_classes := set(class_count.keys()) - defined_classes:
         msg = f"Class count contains classes {non_existing_classes} for which properties are not defined in Data Model!"
@@ -118,16 +120,16 @@ def generate_triples(
 
     # Subset data model to only classes that are defined in class count
     rules = (
-        InformationAnalysis(rules).subset_rules(set(class_count.keys()))
+        SubsetInformationRules(classes=set(class_count.keys())).transform(rules)
         if defined_classes != set(class_count.keys())
         else rules
     )
 
-    class_linkage = InformationAnalysis(rules).class_linkage().to_pandas()
+    class_linkage = analysis.class_linkage().to_pandas()
 
     # Remove one of symmetric pairs from class linkage to maintain proper linking
     # among instances of symmetrically linked classes
-    if sym_pairs := InformationAnalysis(rules).symmetrically_connected_classes():
+    if sym_pairs := analysis.symmetrically_connected_classes():
         class_linkage = _remove_higher_occurring_sym_pair(class_linkage, sym_pairs)
 
     # Remove any of symmetric pairs containing classes that are not present class count
@@ -137,7 +139,7 @@ def generate_triples(
     generation_order = _prettify_generation_order(_get_generation_order(class_linkage))
 
     # Generated simple view of data model
-    class_property_pairs = InformationAnalysis(rules).classes_with_properties(consider_inheritance=True)
+    class_property_pairs = analysis.properties_by_class(include_ancestors=True)
 
     # pregenerate instance ids for each remaining class
     instance_ids = {