cognite-neat 0.81.12__py3-none-any.whl → 0.82.1__py3-none-any.whl

cognite/neat/rules/analysis/_information_rules.py

@@ -2,7 +2,7 @@ import itertools
 import logging
 import warnings
 from collections import defaultdict
-from typing import Any, cast
+from typing import Any
 
 import pandas as pd
 from pydantic import ValidationError
@@ -17,24 +17,11 @@ from ._base import BaseAnalysis
 
 
 class InformationArchitectRulesAnalysis(BaseAnalysis):
+    """Assumes analysis over only the complete schema"""
+
     def __init__(self, rules: InformationRules):
         self.rules = rules
 
-    @property
-    def referred_classes(self) -> set[ClassEntity]:
-        return self.directly_referred_classes.union(self.inherited_referred_classes)
-
-    @property
-    def referred_classes_properties(self) -> list[InformationProperty]:
-        referred_classes_properties = []
-        class_properties_dict = self.classes_with_properties(use_reference=True)
-
-        for class_ in self.referred_classes:
-            if class_ in class_properties_dict:
-                referred_classes_properties.extend(class_properties_dict[class_])
-
-        return referred_classes_properties
-
     @property
     def directly_referred_classes(self) -> set[ClassEntity]:
         return {
@@ -51,19 +38,17 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
         dir_referred_classes = self.directly_referred_classes
         inherited_referred_classes = []
         for class_ in dir_referred_classes:
-            inherited_referred_classes.extend(self.class_inheritance_path(class_, use_reference=True))
+            inherited_referred_classes.extend(self.class_inheritance_path(class_))
         return set(inherited_referred_classes)
 
-    def class_parent_pairs(self, use_reference: bool = False) -> dict[ClassEntity, list[ParentClassEntity]]:
+    def class_parent_pairs(self) -> dict[ClassEntity, list[ParentClassEntity]]:
         """This only returns class - parent pairs only if parent is in the same data model"""
         class_subclass_pairs: dict[ClassEntity, list[ParentClassEntity]] = {}
 
-        rules = cast(InformationRules, self.rules.reference if use_reference else self.rules)
-
-        if not rules:
+        if not self.rules:
             return class_subclass_pairs
 
-        for definition in rules.classes:
+        for definition in self.rules.classes:
             class_subclass_pairs[definition.class_] = []
 
             if definition.parent is None:
@@ -81,13 +66,12 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
         return class_subclass_pairs
 
     def classes_with_properties(
-        self, consider_inheritance: bool = False, use_reference: bool = False
+        self, consider_inheritance: bool = False
     ) -> dict[ClassEntity, list[InformationProperty]]:
         """Returns classes that have been defined in the data model.
 
         Args:
             consider_inheritance: Whether to consider inheritance or not. Defaults False
-            use_reference: Whether to use reference rules or not. Defaults False
 
         Returns:
             Dictionary of classes with a list of properties defined for them
@@ -103,21 +87,19 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
 
         class_property_pairs: dict[ClassEntity, list[InformationProperty]] = defaultdict(list)
 
-        rules = cast(InformationRules, self.rules.reference if use_reference else self.rules)
-
-        for property_ in rules.properties:
+        for property_ in self.rules.properties:
             class_property_pairs[property_.class_].append(property_)
 
         if consider_inheritance:
-            class_parent_pairs = self.class_parent_pairs(use_reference=use_reference)
+            class_parent_pairs = self.class_parent_pairs()
             for class_ in class_parent_pairs:
                 self._add_inherited_properties(class_, class_property_pairs, class_parent_pairs)
 
         return class_property_pairs
 
-    def class_inheritance_path(self, class_: ClassEntity | str, use_reference: bool = False) -> list[ClassEntity]:
+    def class_inheritance_path(self, class_: ClassEntity | str) -> list[ClassEntity]:
         class_ = class_ if isinstance(class_, ClassEntity) else ClassEntity.load(class_)
-        class_parent_pairs = self.class_parent_pairs(use_reference)
+        class_parent_pairs = self.class_parent_pairs()
         return get_inheritance_path(class_, class_parent_pairs)
 
     @classmethod
@@ -133,8 +115,13 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
             if parent.as_class_entity() in class_property_pairs:
                 for property_ in class_property_pairs[parent.as_class_entity()]:
                     property_ = property_.model_copy()
-                    # this corresponds to importing properties from parent class
+
+                    # This corresponds to importing properties from parent class
+                    # making sure that the property is attached to desired child class
                     property_.class_ = class_
+                    property_.inherited = True
+
+                    # need same if we have RDF path to make sure that the starting class is the
 
                     if class_ in class_property_pairs:
                         class_property_pairs[class_].append(property_)
@@ -142,14 +129,13 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
                         class_property_pairs[class_] = [property_]
 
     def class_property_pairs(
-        self, only_rdfpath: bool = False, consider_inheritance: bool = False, use_reference: bool = False
+        self, only_rdfpath: bool = False, consider_inheritance: bool = False
     ) -> dict[ClassEntity, dict[str, InformationProperty]]:
         """Returns a dictionary of classes with a dictionary of properties associated with them.
 
         Args:
             only_rdfpath : To consider only properties which have rule `rdfpath` set. Defaults False
             consider_inheritance: Whether to consider inheritance or not. Defaults False
-            use_reference : Whether to use reference rules or not. Defaults False
 
         Returns:
             Dictionary of classes with a dictionary of properties associated with them.
@@ -178,7 +164,7 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
 
         class_property_pairs = {}
 
-        for class_, properties in self.classes_with_properties(consider_inheritance, use_reference).items():
+        for class_, properties in self.classes_with_properties(consider_inheritance).items():
             processed_properties = {}
             for property_ in properties:
                 if property_.property_ in processed_properties:
@@ -197,12 +183,11 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
 
         return class_property_pairs
 
-    def class_linkage(self, consider_inheritance: bool = False, use_reference: bool = False) -> pd.DataFrame:
+    def class_linkage(self, consider_inheritance: bool = False) -> pd.DataFrame:
         """Returns a dataframe with the class linkage of the data model.
 
         Args:
             consider_inheritance: Whether to consider inheritance or not. Defaults False
-            use_reference: Whether to use reference rules or not. Defaults False
 
         Returns:
             Dataframe with the class linkage of the data model
@@ -210,7 +195,7 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
 
         class_linkage = pd.DataFrame(columns=["source_class", "target_class", "connecting_property", "max_occurrence"])
 
-        class_property_pairs = self.classes_with_properties(consider_inheritance, use_reference)
+        class_property_pairs = self.classes_with_properties(consider_inheritance)
         properties = list(itertools.chain.from_iterable(class_property_pairs.values()))
 
         for property_ in properties:
@@ -230,56 +215,50 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
 
         return class_linkage
 
-    def connected_classes(self, consider_inheritance: bool = False, use_reference: bool = False) -> set[ClassEntity]:
+    def connected_classes(self, consider_inheritance: bool = False) -> set[ClassEntity]:
         """Return a set of classes that are connected to other classes.
 
         Args:
             consider_inheritance: Whether to consider inheritance or not. Defaults False
-            use_reference: Whether to use reference rules or not. Defaults False
 
         Returns:
             Set of classes that are connected to other classes
         """
-        class_linkage = self.class_linkage(consider_inheritance, use_reference)
+        class_linkage = self.class_linkage(consider_inheritance)
         return set(class_linkage.source_class.values).union(set(class_linkage.target_class.values))
 
-    def defined_classes(self, consider_inheritance: bool = False, use_reference: bool = False) -> set[ClassEntity]:
+    def defined_classes(self, consider_inheritance: bool = False) -> set[ClassEntity]:
         """Returns classes that have properties defined for them in the data model.
 
         Args:
             consider_inheritance: Whether to consider inheritance or not. Defaults False
-            use_reference: Whether to use reference rules or not. Defaults False
 
         Returns:
             Set of classes that have been defined in the data model
         """
-        class_property_pairs = self.classes_with_properties(consider_inheritance, use_reference)
+        class_property_pairs = self.classes_with_properties(consider_inheritance)
         properties = list(itertools.chain.from_iterable(class_property_pairs.values()))
 
         return {property.class_ for property in properties}
 
-    def disconnected_classes(self, consider_inheritance: bool = False, use_reference: bool = False) -> set[ClassEntity]:
+    def disconnected_classes(self, consider_inheritance: bool = False) -> set[ClassEntity]:
         """Return a set of classes that are disconnected (i.e. isolated) from other classes.
 
         Args:
             consider_inheritance: Whether to consider inheritance or not. Defaults False
-            use_reference: Whether to use reference rules or not. Defaults False
 
         Returns:
             Set of classes that are disconnected from other classes
         """
-        return self.defined_classes(consider_inheritance, use_reference) - self.connected_classes(
-            consider_inheritance, use_reference
-        )
+        return self.defined_classes(consider_inheritance) - self.connected_classes(consider_inheritance)
 
     def symmetrically_connected_classes(
-        self, consider_inheritance: bool = False, use_reference: bool = False
+        self, consider_inheritance: bool = False
     ) -> set[tuple[ClassEntity, ClassEntity]]:
         """Returns a set of pairs of symmetrically linked classes.
 
         Args:
             consider_inheritance: Whether to consider inheritance or not. Defaults False
-            use_reference: Whether to use reference rules or not. Defaults False
 
         Returns:
             Set of pairs of symmetrically linked classes
@@ -293,7 +272,7 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
         # TODO: Find better name for this method
         sym_pairs: set[tuple[ClassEntity, ClassEntity]] = set()
 
-        class_linkage = self.class_linkage(consider_inheritance, use_reference)
+        class_linkage = self.class_linkage(consider_inheritance)
         if class_linkage.empty:
             return sym_pairs
 
@@ -321,13 +300,12 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
             class_dict[str(definition.class_.suffix)] = definition
         return class_dict
 
-    def subset_rules(self, desired_classes: set[ClassEntity], use_reference: bool = False) -> InformationRules:
+    def subset_rules(self, desired_classes: set[ClassEntity]) -> InformationRules:
         """
         Subset rules to only include desired classes and their properties.
 
         Args:
             desired_classes: Desired classes to include in the reduced data model
-            use_reference: Whether to use reference rules or not. Defaults False
 
         Returns:
             Instance of InformationRules
@@ -350,9 +328,7 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
             only with base Pydantic validators.
         """
 
-        rules = cast(InformationRules, self.rules.reference if use_reference else self.rules)
-
-        if rules.metadata.schema_ is not SchemaCompleteness.complete:
+        if self.rules.metadata.schema_ is not SchemaCompleteness.complete:
             raise ValueError("Rules are not complete cannot perform reduction!")
         class_as_dict = self.as_class_dict()
         class_parents_pairs = self.class_parent_pairs()
@@ -380,8 +356,8 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
             )
 
         reduced_data_model: dict[str, Any] = {
-            "metadata": rules.metadata.model_copy(),
-            "prefixes": (rules.prefixes or {}).copy(),
+            "metadata": self.rules.metadata.model_copy(),
+            "prefixes": (self.rules.prefixes or {}).copy(),
             "classes": [],
             "properties": [],
         }

cognite/neat/rules/importers/_inference2rules.py

@@ -17,7 +17,7 @@ from cognite.neat.rules.models.information import (
     InformationMetadata,
     InformationRulesInput,
 )
-from cognite.neat.utils.utils import get_namespace, remove_namespace
+from cognite.neat.utils.utils import get_namespace, remove_namespace, uri_to_short_form
 
 ORDERED_CLASSES_QUERY = """SELECT ?class (count(?s) as ?instances )
                            WHERE { ?s a ?class . }
@@ -176,6 +176,10 @@ class InferenceImporter(BaseImporter):
                         "max_count": cast(RdfLiteral, occurrence).value,
                         "value_type": value_type_id,
                         "reference": property_uri,
+                        "transformation": (
+                            f"{uri_to_short_form(class_definition['reference'], prefixes)}"
+                            f"({uri_to_short_form(cast(URIRef, property_uri), prefixes)})"
+                        ),
                         "comment": (
                             f"Class <{class_id}> has property <{property_id}> with "
                             f"value type <{value_type_id}> which occurs <1> times in the graph"

cognite/neat/rules/importers/_spreadsheet2rules.py

@@ -15,12 +15,14 @@ from cognite.neat.rules import issues
 from cognite.neat.rules.issues import IssueList
 from cognite.neat.rules.models import (
     RULES_PER_ROLE,
+    AssetRules,
     DMSRules,
     DomainRules,
     InformationRules,
     RoleTypes,
     SchemaCompleteness,
 )
+from cognite.neat.rules.models.asset import AssetRulesInput
 from cognite.neat.rules.models.dms import DMSRulesInput
 from cognite.neat.rules.models.information import InformationRulesInput
 from cognite.neat.utils.auxiliary import local_import
@@ -35,6 +37,7 @@ SOURCE_SHEET__TARGET_FIELD__HEADERS = [
         {
             RoleTypes.domain_expert: "Property",
             RoleTypes.information_architect: "Property",
+            RoleTypes.asset_architect: "Property",
             RoleTypes.dms_architect: "View Property",
         },
     ),
@@ -266,6 +269,8 @@ class ExcelImporter(BaseImporter):
                 rules = DMSRulesInput.load(sheets).as_rules()
             elif rules_cls is InformationRules:
                 rules = InformationRulesInput.load(sheets).as_rules()
+            elif rules_cls is AssetRules:
+                rules = AssetRulesInput.load(sheets).as_rules()
             else:
                 rules = rules_cls.model_validate(sheets)  # type: ignore[attr-defined]
 
@@ -300,7 +305,7 @@ class GoogleSheetImporter(BaseImporter):
         import gspread  # type: ignore[import]
 
         role = role or RoleTypes.domain_expert
-        rules_model = cast(DomainRules | InformationRules | DMSRules, RULES_PER_ROLE[role])
+        rules_model = cast(DomainRules | InformationRules | AssetRules | DMSRules, RULES_PER_ROLE[role])
 
         client_google = gspread.service_account()
         google_sheet = client_google.open_by_key(self.sheet_id)

cognite/neat/rules/models/__init__.py

@@ -1,3 +1,4 @@
+from cognite.neat.rules.models.asset import AssetRules
 from cognite.neat.rules.models.domain import DomainRules
 from cognite.neat.rules.models.information._rules import InformationRules
 
@@ -5,9 +6,10 @@ from ._base import DataModelType, ExtensionCategory, RoleTypes, SchemaCompletene
 from .dms._rules import DMSRules
 from .dms._schema import DMSSchema
 
-RULES_PER_ROLE: dict[RoleTypes, type[DomainRules] | type[InformationRules] | type[DMSRules]] = {
+RULES_PER_ROLE: dict[RoleTypes, type[DomainRules] | type[InformationRules] | type[AssetRules] | type[DMSRules]] = {
     RoleTypes.domain_expert: DomainRules,
     RoleTypes.information_architect: InformationRules,
+    RoleTypes.asset_architect: AssetRules,
     RoleTypes.dms_architect: DMSRules,
 }
 
@@ -15,6 +17,7 @@ RULES_PER_ROLE: dict[RoleTypes, type[DomainRules] | type[InformationRules] | typ
 __all__ = [
     "DomainRules",
     "InformationRules",
+    "AssetRules",
     "DMSRules",
     "RULES_PER_ROLE",
     "DMSSchema",

cognite/neat/rules/models/_base.py

@@ -151,6 +151,7 @@ class DataModelType(StrEnum):
 class RoleTypes(StrEnum):
     domain_expert = "domain expert"
     information_architect = "information architect"
+    asset_architect = "asset architect"
     dms_architect = "DMS Architect"
 
 

cognite/neat/rules/models/asset/__init__.py

@@ -0,0 +1,10 @@
+from ._rules import AssetClass, AssetMetadata, AssetProperty, AssetRules
+from ._rules_input import AssetRulesInput
+
+__all__ = [
+    "AssetRules",
+    "AssetMetadata",
+    "AssetClass",
+    "AssetProperty",
+    "AssetRulesInput",
+]

cognite/neat/rules/models/asset/_converter.py

@@ -0,0 +1,4 @@
+from cognite.neat.rules.models.information._converter import _InformationRulesConverter
+
+
+class _AssetRulesConverter(_InformationRulesConverter): ...

cognite/neat/rules/models/asset/_rules.py

@@ -0,0 +1,156 @@
+import sys
+from typing import TYPE_CHECKING, Any, ClassVar, Literal, cast
+
+from pydantic import Field, field_validator, model_validator
+from pydantic.main import IncEx
+from rdflib import Namespace
+
+from cognite.neat.constants import PREFIXES
+from cognite.neat.issues import MultiValueError
+from cognite.neat.rules import issues
+from cognite.neat.rules.models._base import BaseRules, RoleTypes, SheetList
+from cognite.neat.rules.models.domain import DomainRules
+from cognite.neat.rules.models.entities import (
+    CdfResourceEntityList,
+    ClassEntity,
+    MultiValueTypeInfo,
+    ParentClassEntity,
+    Undefined,
+)
+from cognite.neat.rules.models.information import (
+    InformationClass,
+    InformationMetadata,
+    InformationProperty,
+    InformationRules,
+)
+
+if TYPE_CHECKING:
+    from cognite.neat.rules.models.dms._rules import DMSRules
+
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+
+class AssetMetadata(InformationMetadata):
+    role: ClassVar[RoleTypes] = RoleTypes.asset_architect
+
+
+class AssetClass(InformationClass): ...
+
+
+class AssetProperty(InformationProperty):
+    """
+    A property is a characteristic of a class. It is a named attribute of a class that describes a range of values
+    or a relationship to another class.
+
+    Args:
+        class_: Class ID to which property belongs
+        property_: Property ID of the property
+        name: Property name.
+        value_type: Type of value property will hold (data or link to another class)
+        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
+        reference: Reference to the source of the information, HTTP URI
+        match_type: The match type of the resource being described and the source entity.
+        transformation: Actual rule for the transformation from source to target representation of
+              knowledge graph. Defaults to None (no transformation)
+        implementation: Details on how given class-property is implemented in the classic CDF
+    """
+
+    implementation: CdfResourceEntityList | None = Field(alias="Implementation", default=None)
+
+
+class AssetRules(BaseRules):
+    metadata: AssetMetadata = Field(alias="Metadata")
+    properties: SheetList[AssetProperty] = Field(alias="Properties")
+    classes: SheetList[AssetClass] = Field(alias="Classes")
+    prefixes: dict[str, Namespace] = Field(default_factory=lambda: PREFIXES.copy())
+    last: "AssetRules | None" = Field(None, alias="Last")
+    reference: "AssetRules | None" = Field(None, alias="Reference")
+
+    @field_validator("prefixes", mode="before")
+    def parse_str(cls, values: Any) -> Any:
+        if isinstance(values, dict):
+            return {key: Namespace(value) if isinstance(value, str) else value for key, value in values.items()}
+        return values
+
+    @model_validator(mode="after")
+    def update_entities_prefix(self) -> Self:
+        # update expected_value_types
+        for property_ in self.properties:
+            if isinstance(property_.value_type, ClassEntity) and property_.value_type.prefix is Undefined:
+                property_.value_type.prefix = self.metadata.prefix
+
+            if isinstance(property_.value_type, MultiValueTypeInfo):
+                property_.value_type.set_default_prefix(self.metadata.prefix)
+
+            if property_.class_.prefix is Undefined:
+                property_.class_.prefix = self.metadata.prefix
+
+        # update parent classes
+        for class_ in self.classes:
+            if class_.parent:
+                for parent in cast(list[ParentClassEntity], class_.parent):
+                    if not isinstance(parent.prefix, str):
+                        parent.prefix = self.metadata.prefix
+            if class_.class_.prefix is Undefined:
+                class_.class_.prefix = self.metadata.prefix
+
+        return self
+
+    @model_validator(mode="after")
+    def post_validation(self) -> "AssetRules":
+        from ._validation import AssetPostValidation
+
+        issue_list = AssetPostValidation(cast(InformationRules, self)).validate()
+        if issue_list.warnings:
+            issue_list.trigger_warnings()
+        if issue_list.has_errors:
+            raise MultiValueError([error for error in issue_list if isinstance(error, issues.NeatValidationError)])
+        return self
+
+    def dump(
+        self,
+        mode: Literal["python", "json"] = "python",
+        by_alias: bool = False,
+        exclude: IncEx = None,
+        exclude_none: bool = False,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        as_reference: bool = False,
+    ) -> dict[str, Any]:
+        from ._serializer import _AssetRulesSerializer
+
+        dumped = self.model_dump(
+            mode=mode,
+            by_alias=by_alias,
+            exclude=exclude,
+            exclude_none=exclude_none,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+        )
+        prefix = self.metadata.prefix
+        serializer = _AssetRulesSerializer(by_alias, prefix)
+        cleaned = serializer.clean(dumped, as_reference)
+        last = "Last" if by_alias else "last"
+        if last_dump := cleaned.get(last):
+            cleaned[last] = serializer.clean(last_dump, False)
+        reference = "Reference" if by_alias else "reference"
+        if self.reference and (ref_dump := cleaned.get(reference)):
+            prefix = self.reference.metadata.prefix
+            cleaned[reference] = _AssetRulesSerializer(by_alias, prefix).clean(ref_dump, True)
+        return cleaned
+
+    def as_domain_rules(self) -> DomainRules:
+        from ._converter import _AssetRulesConverter
+
+        return _AssetRulesConverter(cast(InformationRules, self)).as_domain_rules()
+
+    def as_dms_architect_rules(self) -> "DMSRules":
+        from ._converter import _AssetRulesConverter
+
+        return _AssetRulesConverter(cast(InformationRules, self)).as_dms_architect_rules()