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

cognite/neat/_rules/models/information/_rules.py

@@ -1,5 +1,4 @@
 import math
-import sys
 from collections.abc import Hashable
 from typing import TYPE_CHECKING, Any, ClassVar
 
@@ -28,14 +27,15 @@ from cognite.neat._rules.models._types import (
     ClassEntityType,
     InformationPropertyType,
     MultiValueTypeType,
+    URIRefType,
 )
+
+# NeatIdType,
 from cognite.neat._rules.models.data_types import DataType
 from cognite.neat._rules.models.entities import (
     ClassEntity,
     ClassEntityList,
     Entity,
-    MultiValueTypeInfo,
-    Undefined,
     UnknownEntity,
 )
 
@@ -43,19 +43,13 @@ if TYPE_CHECKING:
     from cognite.neat._rules.models import DMSRules
 
 
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
-
-
 class InformationMetadata(BaseMetadata):
     role: ClassVar[RoleTypes] = RoleTypes.information
     aspect: ClassVar[DataModelAspect] = DataModelAspect.logical
 
     # Linking to Conceptual and Physical data model aspects
-    physical: URIRef | None = Field(None, description="Link to the logical data model aspect")
-    conceptual: URIRef | None = Field(None, description="Link to the logical data model aspect")
+    physical: URIRef | str | None = Field(None, description="Link to the physical data model aspect")
+    conceptual: URIRef | str | None = Field(None, description="Link to the conceptual data model aspect")
 
 
 def _get_metadata(context: Any) -> InformationMetadata | None:
@@ -79,6 +73,12 @@ class InformationClass(SheetRow):
     description: str | None = Field(alias="Description", default=None)
     implements: ClassEntityList | None = Field(alias="Implements", default=None)
 
+    physical: URIRefType | None = Field(
+        None,
+        description="Link to the class representation in the physical data model aspect",
+    )
+    conceptual: URIRefType | None = Field(None, description="Link to the conceptual data model aspect")
+
     def _identifier(self) -> tuple[Hashable, ...]:
         return (self.class_,)
 
@@ -137,6 +137,12 @@ class InformationProperty(SheetRow):
         description="Flag to indicate if the property is inherited, only use for internal purposes",
     )
 
+    physical: URIRefType | None = Field(
+        None,
+        description="Link to the class representation in the physical data model aspect",
+    )
+    conceptual: URIRefType | None = Field(None, description="Link to the conceptual data model aspect")
+
     def _identifier(self) -> tuple[Hashable, ...]:
         return self.class_, self.property_
 
@@ -155,21 +161,6 @@ class InformationProperty(SheetRow):
         else:
             raise NeatValueError(f"Invalid RDF Path: {value!s}")
 
-    @model_validator(mode="after")
-    def set_default_as_list(self):
-        if (
-            self.type_ == EntityTypes.data_property
-            and self.default
-            and self.is_list
-            and not isinstance(self.default, list)
-        ):
-            if isinstance(self.default, str):
-                if self.default:
-                    self.default = self.default.replace(", ", ",").split(",")
-                else:
-                    self.default = [self.default]
-        return self
-
     @model_validator(mode="after")
     def set_type_for_default(self):
         if self.type_ == EntityTypes.data_property and self.default:
@@ -243,41 +234,6 @@ class InformationRules(BaseRules):
             values = get_default_prefixes()
         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 implements
-        for class_ in self.classes:
-            if class_.implements:
-                for parent in class_.implements:
-                    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) -> "InformationRules":
-        from ._validation import InformationPostValidation
-
-        issue_list = InformationPostValidation(self).validate()
-        if issue_list.warnings:
-            issue_list.trigger_warnings()
-        if issue_list.has_errors:
-            raise issue_list.as_exception()
-        return self
-
     def as_dms_rules(self) -> "DMSRules":
         from cognite.neat._rules.transformers._converters import _InformationRulesConverter
 

cognite/neat/_rules/models/information/_rules_input.py

@@ -33,8 +33,8 @@ class InformationInputMetadata(InputComponent[InformationMetadata]):
     description: str | None = None
     created: datetime | str | None = None
     updated: datetime | str | None = None
-    physical: str | None = None
-    conceptual: str | None = None
+    physical: str | URIRef | None = None
+    conceptual: str | URIRef | None = None
 
     @classmethod
     def _get_verified_cls(cls) -> type[InformationMetadata]:
@@ -81,6 +81,11 @@ class InformationInputProperty(InputComponent[InformationProperty]):
     transformation: str | None = None
     # Only used internally
     inherited: bool = False
+    neatId: str | URIRef | None = None
+
+    # linking
+    physical: str | URIRef | None = None
+    conceptual: str | URIRef | None = None
 
     @classmethod
     def _get_verified_cls(cls) -> type[InformationProperty]:
@@ -99,6 +104,10 @@ class InformationInputClass(InputComponent[InformationClass]):
     name: str | None = None
     description: str | None = None
     implements: str | list[ClassEntity] | None = None
+    neatId: str | URIRef | None = None
+    # linking
+    physical: str | URIRef | None = None
+    conceptual: str | URIRef | None = None
 
     @classmethod
     def _get_verified_cls(cls) -> type[InformationClass]:

cognite/neat/_rules/models/information/_validation.py

@@ -1,17 +1,22 @@
 import itertools
 from collections import Counter
-from typing import cast
 
 from cognite.neat._issues import IssueList
-from cognite.neat._issues.errors import NeatValueError, ResourceNotDefinedError
+from cognite.neat._issues.errors import NeatValueError
+from cognite.neat._issues.errors._resources import ResourceNotDefinedError
 from cognite.neat._issues.warnings._models import UndefinedClassWarning
-from cognite.neat._rules._constants import EntityTypes
+from cognite.neat._issues.warnings._resources import (
+    ResourceNotDefinedWarning,
+    ResourceRegexViolationWarning,
+)
+from cognite.neat._rules._constants import PATTERNS, EntityTypes
 from cognite.neat._rules.models.entities import ClassEntity, UnknownEntity
+from cognite.neat._rules.models.entities._multi_value import MultiValueTypeInfo
 
 from ._rules import InformationRules
 
 
-class InformationPostValidation:
+class InformationValidation:
     """This class does all the validation of the Information rules that have dependencies
     between components."""
 
@@ -25,14 +30,15 @@ class InformationPostValidation:
     def validate(self) -> IssueList:
         self._namespaces_reassigned()
         self._classes_without_properties()
+        self._undefined_classes()
         self._parent_class_defined()
         self._referenced_classes_exist()
         self._referenced_value_types_exist()
+        self._regex_compliance_with_dms()
 
         return self.issue_list
 
     def _classes_without_properties(self) -> None:
-        # needs to be complete for this validation to pass
         defined_classes = {class_.class_ for class_ in self.classes}
         referred_classes = {property_.class_ for property_ in self.properties}
         class_parent_pairs = self._class_parent_pairs()
@@ -44,13 +50,27 @@ class InformationPostValidation:
                 # same prefix, meaning same space
                 if not class_parent_pairs[class_] and class_.prefix == self.metadata.prefix:
                     self.issue_list.append(
-                        ResourceNotDefinedError[ClassEntity](
+                        ResourceNotDefinedWarning(
                             resource_type="class",
                             identifier=class_,
-                            location="Classes sheet",
+                            location="Properties sheet",
                         )
                     )
 
+    def _undefined_classes(self) -> None:
+        defined_classes = {class_.class_ for class_ in self.classes}
+        referred_classes = {property_.class_ for property_ in self.properties}
+
+        if undefined_classes := referred_classes.difference(defined_classes):
+            for class_ in undefined_classes:
+                self.issue_list.append(
+                    ResourceNotDefinedError(
+                        identifier=class_,
+                        resource_type="class",
+                        location="Classes sheet",
+                    )
+                )
+
     def _parent_class_defined(self) -> None:
         """This is a validation to check if the parent class of a class is defined in the classes sheet."""
         class_parent_pairs = self._class_parent_pairs()
@@ -63,7 +83,7 @@ class InformationPostValidation:
                     self.issue_list.append(UndefinedClassWarning(class_id=str(parent)))
                 else:
                     self.issue_list.append(
-                        ResourceNotDefinedError[ClassEntity](
+                        ResourceNotDefinedWarning(
                             resource_type="class",
                             identifier=parent,
                             location="Classes sheet",
@@ -79,7 +99,7 @@ class InformationPostValidation:
         if missing_classes := classes_with_explicit_properties.difference(defined_classes):
             for class_ in missing_classes:
                 self.issue_list.append(
-                    ResourceNotDefinedError[ClassEntity](
+                    ResourceNotDefinedWarning(
                         resource_type="class",
                         identifier=class_,
                         location="Classes sheet",
@@ -99,13 +119,89 @@ class InformationPostValidation:
             # Todo: include row and column number
             for missing in missing_value_types:
                 self.issue_list.append(
-                    ResourceNotDefinedError[ClassEntity](
+                    ResourceNotDefinedWarning(
                         resource_type="class",
-                        identifier=cast(ClassEntity, missing),
+                        identifier=missing,
                         location="Classes sheet",
                     )
                 )
 
+    def _regex_compliance_with_dms(self) -> None:
+        """Check regex compliance with DMS of properties, classes and value types."""
+
+        for prop_ in self.properties:
+            if not PATTERNS.dms_property_id_compliance.match(prop_.property_):
+                self.issue_list.append(
+                    ResourceRegexViolationWarning(
+                        prop_.property_,
+                        "Property",
+                        "Properties sheet, Property column",
+                        PATTERNS.dms_property_id_compliance.pattern,
+                    )
+                )
+            if not PATTERNS.view_id_compliance.match(prop_.class_.suffix):
+                self.issue_list.append(
+                    ResourceRegexViolationWarning(
+                        prop_.class_,
+                        "Class",
+                        "Properties sheet, Class column",
+                        PATTERNS.view_id_compliance.pattern,
+                    )
+                )
+
+            # Handling Value Type
+            if (
+                isinstance(prop_.value_type, ClassEntity)
+                and prop_.value_type != UnknownEntity()
+                and not PATTERNS.view_id_compliance.match(prop_.value_type.suffix)
+            ):
+                self.issue_list.append(
+                    ResourceRegexViolationWarning(
+                        prop_.value_type,
+                        "Value Type",
+                        "Properties sheet, Value Type column",
+                        PATTERNS.view_id_compliance.pattern,
+                    )
+                )
+            if isinstance(prop_.value_type, MultiValueTypeInfo):
+                for value_type in prop_.value_type.types:
+                    if (
+                        isinstance(prop_.value_type, ClassEntity)
+                        and prop_.value_type != UnknownEntity()
+                        and not PATTERNS.view_id_compliance.match(value_type.suffix)
+                    ):
+                        self.issue_list.append(
+                            ResourceRegexViolationWarning(
+                                value_type,
+                                "Value Type",
+                                "Properties sheet, Value Type column",
+                                PATTERNS.view_id_compliance.pattern,
+                            )
+                        )
+
+        for class_ in self.classes:
+            if not PATTERNS.view_id_compliance.match(class_.class_.suffix):
+                self.issue_list.append(
+                    ResourceRegexViolationWarning(
+                        class_.class_,
+                        "Class",
+                        "Classes sheet, Class column",
+                        PATTERNS.view_id_compliance.pattern,
+                    )
+                )
+
+            if class_.implements:
+                for parent in class_.implements:
+                    if not PATTERNS.view_id_compliance.match(parent.suffix):
+                        self.issue_list.append(
+                            ResourceRegexViolationWarning(
+                                parent,
+                                "Class",
+                                "Classes sheet, Implements column",
+                                PATTERNS.view_id_compliance.pattern,
+                            )
+                        )
+
     def _class_parent_pairs(self) -> dict[ClassEntity, list[ClassEntity]]:
         class_parent_pairs: dict[ClassEntity, list[ClassEntity]] = {}
         classes = self.rules.model_copy(deep=True).classes

cognite/neat/_rules/models/mapping/_classic2core.py

@@ -32,7 +32,7 @@ def load_classic_to_core_mapping(org_name: str, source_space: str, source_versio
     if not isinstance(read.rules, DMSInputRules):
         raise NeatValueError(f"Expected DMS rules, but got {type(read.rules).__name__}")
 
-    verified = VerifyDMSRules(errors="raise", post_validate=False).transform(read)
+    verified = VerifyDMSRules(errors="raise", validate=False).transform(read)
 
     if verified.rules is None:
         raise NeatValueError("Failed to verify the rules.")

cognite/neat/_rules/models/mapping/_classic2core.yaml

@@ -65,7 +65,7 @@ properties:
   index: source
   is_list: false
   nullable: true
-  value_type: cdf_cdm:SourceSystem(version=v1)
+  value_type: cdf_cdm:CogniteSourceSystem(version=v1)
   view: ClassicAsset
   view_property: source
 - container: cdf_cdm:CogniteDescribable
@@ -124,7 +124,7 @@ properties:
   index: source
   is_list: false
   nullable: true
-  value_type: cdf_cdm:SourceSystem(version=v1)
+  value_type: cdf_cdm:CogniteSourceSystem(version=v1)
   view: ClassicEvent
   view_property: source
 - container: cdf_cdm:CogniteSchedulable
@@ -196,7 +196,7 @@ properties:
   index: source
   is_list: false
   nullable: true
-  value_type: cdf_cdm:SourceSystem(version=v1)
+  value_type: cdf_cdm:CogniteSourceSystem(version=v1)
   view: ClassicFile
   view_property: source
 - container: cdf_cdm:CogniteSourceable
@@ -306,7 +306,7 @@ properties:
   is_list: false
   name: Unit
   nullable: true
-  value_type: Unit
+  value_type: cdf_cdm:CogniteUnit(version=v1)
   view: ClassicTimeSeries
   view_property: unitExternalId
 views:
@@ -315,6 +315,10 @@ views:
   implements: cdf_cdm:CogniteDescribable(version=v1)
   in_model: true
   view: cdf_cdm:CogniteSourceSystem(version=v1)
+- description: Represents a single unit of measurement
+  implements: cdf_cdm:CogniteDescribable(version=v1)
+  in_model: true
+  view: cdf_cdm:CogniteUnit(version=v1)
 - description: Assets represent systems that support industrial functions or processes.
     Assets are often called 'functional location'.
   implements: cdf_cdm:CogniteAsset(version=v1)

cognite/neat/_rules/transformers/__init__.py

@@ -9,7 +9,7 @@ from ._converters import (
     ToCompliantEntities,
     ToExtension,
 )
-from ._mapping import MapOneToOne, RuleMapper
+from ._mapping import AsParentPropertyId, MapOneToOne, RuleMapper
 from ._pipelines import ImporterPipeline
 from ._verification import VerifyAnyRules, VerifyDMSRules, VerifyInformationRules
 
@@ -30,4 +30,5 @@ __all__ = [
     "ToExtension",
     "ReduceCogniteModel",
     "SetIDDMSModel",
+    "AsParentPropertyId",
 ]