cognite-neat 0.99.0__py3-none-any.whl → 0.100.0__py3-none-any.whl

cognite/neat/_issues/warnings/_resources.py

@@ -13,6 +13,21 @@ class ResourceNeatWarning(NeatWarning, Generic[T_Identifier]):
     resource_type: ResourceType
 
 
+@dataclass(unsafe_hash=True)
+class ResourceRegexViolationWarning(ResourceNeatWarning):
+    """The {resource_type} with identifier {identifier} in the {location} is violating
+    the CDF regex {regex}. This will lead to errors when converting to DMS data model.
+    """
+
+    fix = (
+        "Either export the data model and make the necessary changes manually"
+        " or run prepare.cdf_compliant_external_ids."
+    )
+
+    location: str
+    regex: str
+
+
 @dataclass(unsafe_hash=True)
 class ResourceNotFoundWarning(ResourceNeatWarning, Generic[T_Identifier, T_ReferenceIdentifier]):
     """The {resource_type} with identifier {identifier} referred by {referred_type} {referred_by} does not exist.
@@ -24,6 +39,30 @@ class ResourceNotFoundWarning(ResourceNeatWarning, Generic[T_Identifier, T_Refer
     referred_type: str
 
 
+@dataclass(unsafe_hash=True)
+class ResourceNotDefinedWarning(ResourceNeatWarning, Generic[T_Identifier, T_ReferenceIdentifier]):
+    """The {resource_type} {identifier} is not defined in the {location}"""
+
+    extra = "{column_name} {row_number} in {sheet_name}"
+    fix = "Define the {resource_type} {identifier} in {location}."
+
+    location: str
+    column_name: str | None = None
+    row_number: int | None = None
+    sheet_name: str | None = None
+
+
+@dataclass(unsafe_hash=True)
+class ResourceRedefinedWarning(ResourceNeatWarning, Generic[T_Identifier, T_ReferenceIdentifier]):
+    """The {resource_type} {identifier} feature {feature} is being redefine from {current_value} to {new_value}.
+    This will be ignored."""
+
+    fix = "Avoid redefinition {resource_type} features"
+    feature: str
+    current_value: str
+    new_value: str
+
+
 @dataclass(unsafe_hash=True)
 class ResourcesDuplicatedWarning(NeatWarning, Generic[T_Identifier]):
     """Duplicated {resource_type} with identifiers {resources} were found. {default_action}"""
@@ -37,12 +76,12 @@ class ResourcesDuplicatedWarning(NeatWarning, Generic[T_Identifier]):
 
 @dataclass(unsafe_hash=True)
 class ResourceRetrievalWarning(NeatWarning, Generic[T_Identifier]):
-    """Failed to retrieve {resource_type} with identifiers {resources}. Continuing without
+    """Failed to retrieve {resource_type} with identifier(s) {resources}. Continuing without
     these resources."""
 
     extra = "The error was: {error}"
 
-    fix = "Check the error."
+    fix = "Check the error and fix accordingly."
 
     resources: frozenset[T_Identifier]
     resource_type: ResourceType

cognite/neat/_issues/warnings/user_modeling.py

@@ -17,7 +17,7 @@ __all__ = [
     "HasDataFilterOnNoPropertiesViewWarning",
     "NodeTypeFilterOnParentViewWarning",
     "HasDataFilterOnViewWithReferencesWarning",
-    "ViewPropertyLimitWarning",
+    "ContainerPropertyLimitWarning",
     "NotNeatSupportedFilterWarning",
     "ParentInDifferentSpaceWarning",
 ]
@@ -89,15 +89,15 @@ class HasDataFilterOnViewWithReferencesWarning(UserModelingWarning):
 
 
 @dataclass(unsafe_hash=True)
-class ViewPropertyLimitWarning(UserModelingWarning):
-    """The number of properties in the {view_id} view is {count} which
+class ContainerPropertyLimitWarning(UserModelingWarning):
+    """The number of properties in the {container_id} view is {count} which
     is more than the API limit {limit} properties.
     This can lead to performance issues.
     Reduce the number of properties in the view."""
 
     fix = "Reduce the number of properties in the view"
 
-    view_id: ViewId
+    container_id: ContainerId
     count: int
     limit: int = DMS_CONTAINER_PROPERTY_SIZE_LIMIT
 

cognite/neat/_rules/_constants.py

@@ -106,13 +106,9 @@ VIEW_ID_COMPLIANCE_REGEX = (
 DMS_PROPERTY_ID_COMPLIANCE_REGEX = (
     rf"(?!^({'|'.join(get_reserved_words('property'))})$)" r"(^[a-zA-Z][a-zA-Z0-9_]{0,253}[a-zA-Z0-9]?$)"
 )
-CLASS_ID_COMPLIANCE_REGEX = (
-    rf"(?!^({'|'.join(get_reserved_words('class'))})$)" r"(^[a-zA-Z][a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
-)
+CLASS_ID_COMPLIANCE_REGEX = rf"(?!^({'|'.join(get_reserved_words('class'))})$)" r"(^[a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
 
-INFORMATION_PROPERTY_ID_COMPLIANCE_REGEX = (
-    r"^(\*)|(?!^(Property|property)$)(^[a-zA-Z][a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
-)
+INFORMATION_PROPERTY_ID_COMPLIANCE_REGEX = r"^(\*)|(?!^(Property|property)$)(^[a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
 VERSION_COMPLIANCE_REGEX = r"^[a-zA-Z0-9]([.a-zA-Z0-9_-]{0,41}[a-zA-Z0-9])?$"
 
 

cognite/neat/_rules/analysis/_base.py

@@ -4,23 +4,25 @@ from abc import ABC, abstractmethod
 from collections import defaultdict
 from collections.abc import Set
 from dataclasses import dataclass
-from typing import Generic, TypeVar
+from typing import Generic, TypeVar, cast
 
 import pandas as pd
-from pydantic import BaseModel
+from rdflib import URIRef
 
 from cognite.neat._rules.models._base_rules import BaseRules
 from cognite.neat._rules.models._rdfpath import RDFPath
+from cognite.neat._rules.models.dms._rules import DMSProperty, DMSView
 from cognite.neat._rules.models.entities import (
     ClassEntity,
     Entity,
 )
 from cognite.neat._rules.models.information import InformationProperty
+from cognite.neat._rules.models.information._rules import InformationClass
 from cognite.neat._utils.rdf_ import get_inheritance_path
 
 T_Rules = TypeVar("T_Rules", bound=BaseRules)
-T_Property = TypeVar("T_Property", bound=BaseModel)
-T_Class = TypeVar("T_Class", bound=BaseModel)
+T_Property = TypeVar("T_Property", bound=InformationProperty | DMSProperty)
+T_Class = TypeVar("T_Class", bound=InformationClass | DMSView)
 T_ClassEntity = TypeVar("T_ClassEntity", bound=Entity)
 T_PropertyEntity = TypeVar("T_PropertyEntity", bound=Entity | str)
 
@@ -108,6 +110,14 @@ class BaseAnalysis(ABC, Generic[T_Rules, T_Class, T_Property, T_ClassEntity, T_P
     def inherited_referred_classes(self) -> set[ClassEntity]:
         raise NotImplementedError
 
+    @property
+    def properties_by_neat_id(self) -> dict[URIRef, T_Property]:
+        return {cast(URIRef, prop.neatId): prop for prop in self._get_properties()}
+
+    @property
+    def classes_by_neat_id(self) -> dict[URIRef, T_Class]:
+        return {cast(URIRef, class_.neatId): class_ for class_ in self._get_classes()}
+
     # Todo Lru cache this method.
     def class_parent_pairs(self, allow_different_space: bool = False) -> dict[T_ClassEntity, list[T_ClassEntity]]:
         """This only returns class - parent pairs only if parent is in the same data model"""
@@ -176,7 +186,7 @@ class BaseAnalysis(ABC, Generic[T_Rules, T_Class, T_Property, T_ClassEntity, T_P
             # ParentClassEntity -> ClassEntity to match the type of class_property_pairs
             if parent in class_property_pairs:
                 for property_ in class_property_pairs[parent]:
-                    property_ = property_.model_copy()
+                    property_ = property_.model_copy()  # type: ignore
 
                     # This corresponds to importing properties from parent class
                     # making sure that the property is attached to desired child class

cognite/neat/_rules/analysis/_dms.py

@@ -1,3 +1,7 @@
+from collections import defaultdict
+
+from rdflib import URIRef
+
 from cognite.neat._constants import DMS_LISTABLE_PROPERTY_LIMIT
 from cognite.neat._rules.models.dms import DMSProperty, DMSRules, DMSView
 from cognite.neat._rules.models.entities import ViewEntity
@@ -35,3 +39,19 @@ class DMSAnalysis(BaseAnalysis[DMSRules, DMSView, DMSProperty, ViewEntity, str])
 
     def _get_prop_entity(self, property_: DMSProperty) -> str:
         return property_.view_property
+
+    def views_with_properties_linked_to_classes(
+        self,
+        consider_inheritance: bool = False,
+        allow_different_namespace: bool = False,
+    ) -> dict[ViewEntity, dict[str, URIRef]]:
+        view_property_pairs = self.classes_with_properties(consider_inheritance, allow_different_namespace)
+
+        view_and_properties_with_links: dict[ViewEntity, dict[str, URIRef]] = defaultdict(dict)
+
+        for view, properties in view_property_pairs.items():
+            view_and_properties_with_links[view] = {
+                prop.view_property: prop.logical for prop in properties if prop.logical
+            }
+
+        return view_and_properties_with_links

cognite/neat/_rules/analysis/_information.py

@@ -101,6 +101,28 @@ class InformationAnalysis(BaseAnalysis[InformationRules, InformationClass, Infor
 
         return property_renaming_configuration
 
+    def neat_id_to_transformation_property_uri(self, property_neat_id: URIRef) -> URIRef | None:
+        if (
+            (property_ := self.properties_by_neat_id.get(property_neat_id))
+            and property_.transformation
+            and isinstance(
+                property_.transformation.traversal,
+                SingleProperty,
+            )
+            and (
+                property_.transformation.traversal.property.prefix in self.rules.prefixes
+                or property_.transformation.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]
+            )
+
+            return namespace[property_.transformation.traversal.property.suffix]
+        return None
+
     def property_types(self, class_: ClassEntity) -> dict[str, EntityTypes]:
         property_types = {}
         if definitions := self.class_property_pairs(consider_inheritance=True).get(class_, None):

cognite/neat/_rules/exporters/_base.py

@@ -31,11 +31,9 @@ class BaseExporter(ABC, Generic[T_VerifiedRules, T_Export]):
 class CDFExporter(BaseExporter[T_VerifiedRules, T_Export]):
     @abstractmethod
     def export_to_cdf_iterable(
-        self, rules: T_VerifiedRules, client: NeatClient, dry_run: bool = False, fallback_one_by_one: bool = False
+        self, rules: T_VerifiedRules, client: NeatClient, dry_run: bool = False
     ) -> Iterable[UploadResult]:
         raise NotImplementedError
 
-    def export_to_cdf(
-        self, rules: T_VerifiedRules, client: NeatClient, dry_run: bool = False, fallback_one_by_one: bool = False
-    ) -> UploadResultList:
-        return UploadResultList(self.export_to_cdf_iterable(rules, client, dry_run, fallback_one_by_one))
+    def export_to_cdf(self, rules: T_VerifiedRules, client: NeatClient, dry_run: bool = False) -> UploadResultList:
+        return UploadResultList(self.export_to_cdf_iterable(rules, client, dry_run))