cognite-neat 0.76.1__py3-none-any.whl → 0.76.3__py3-none-any.whl

cognite/neat/rules/issues/dms.py

@@ -9,6 +9,7 @@ from .base import NeatValidationError, ValidationWarning
 __all__ = [
     "DMSSchemaError",
     "DMSSchemaWarning",
+    "IncompleteSchemaError",
     "MissingSpaceError",
     "MissingContainerError",
     "MissingContainerPropertyError",
@@ -19,12 +20,14 @@ __all__ = [
     "DirectRelationMissingSourceWarning",
     "ViewModelVersionNotMatchingWarning",
     "ViewModelSpaceNotMatchingWarning",
+    "ViewMapsToTooManyContainersWarning",
     "DuplicatedViewInDataModelError",
     "ContainerPropertyUsedMultipleTimesError",
     "EmptyContainerWarning",
     "UnsupportedConnectionWarning",
     "MultipleReferenceWarning",
     "HasDataFilterOnNoPropertiesViewWarning",
+    "HasDataFilterAppliedToTooManyContainersWarning",
     "ReverseRelationMissingOtherSideWarning",
     "NodeTypeFilterOnParentViewWarning",
     "ChangingContainerError",
@@ -40,6 +43,24 @@ class DMSSchemaError(NeatValidationError, ABC): ...
 class DMSSchemaWarning(ValidationWarning, ABC): ...
 
 
+@dataclass(frozen=True)
+class IncompleteSchemaError(DMSSchemaError):
+    description = "This error is raised when the schema is claimed to be complete but missing some components"
+    fix = "Either provide the missing components or change the schema to partial"
+    missing_component: dm.ContainerId | dm.ViewId
+
+    def message(self) -> str:
+        return (
+            "The data model schema is set to be complete, however, "
+            f"the referred component {self.missing_component} is not preset."
+        )
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["missing_component"] = self.missing_component
+        return output
+
+
 @dataclass(frozen=True)
 class MissingSpaceError(DMSSchemaError):
     description = "The spaced referred to by the Container/View/Node/Edge/DataModel does not exist"
@@ -250,6 +271,28 @@ class ViewModelSpaceNotMatchingWarning(DMSSchemaWarning):
         return output
 
 
+@dataclass(frozen=True)
+class ViewMapsToTooManyContainersWarning(DMSSchemaWarning):
+    description = "The view maps to more than 10 containers which impacts read/write performance of data model"
+    fix = "Try to have as few containers as possible to which the view maps to"
+    error_name: ClassVar[str] = "ViewMapsToTooManyContainers"
+    view_id: dm.ViewId
+    container_ids: set[dm.ContainerId]
+
+    def message(self) -> str:
+        return (
+            f"The view {self.view_id} maps to total of {len(self.container_ids)},."
+            "Mapping to more than 10 containers is not recommended and can lead to poor performances."
+            "Re-iterate the data model design to reduce the number of containers to which the view maps to."
+        )
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["view_id"] = self.view_id.dump()
+        output["container_ids"] = [container_id.dump() for container_id in self.container_ids]
+        return output
+
+
 @dataclass(frozen=True)
 class ContainerPropertyUsedMultipleTimesError(DMSSchemaError):
     description = "The container property is used multiple times by the same view property"
@@ -442,6 +485,28 @@ class HasDataFilterOnNoPropertiesViewWarning(DMSSchemaWarning):
         return output
 
 
+@dataclass(frozen=True)
+class HasDataFilterAppliedToTooManyContainersWarning(DMSSchemaWarning):
+    description = "The view filter hasData applied to more than 10 containers this will cause DMS API Error"
+    fix = "Do not map to more than 10 containers, alternatively override the filter by using rawFilter"
+    error_name: ClassVar[str] = "HasDataFilterAppliedToTooManyContainers"
+    view_id: dm.ViewId
+    container_ids: set[dm.ContainerId]
+
+    def message(self) -> str:
+        return (
+            f"The view {self.view_id} HasData filter applied to total of {len(self.container_ids)},."
+            "Applying HasData filter to more than 10 containers is not recommended and can lead to DMS API error."
+            "Re-iterate the data model design to reduce the number of containers to which the view maps to."
+        )
+
+    def dump(self) -> dict[str, Any]:
+        output = super().dump()
+        output["view_id"] = self.view_id.dump()
+        output["container_ids"] = [container_id.dump() for container_id in self.container_ids]
+        return output
+
+
 @dataclass(frozen=True)
 class NodeTypeFilterOnParentViewWarning(DMSSchemaWarning):
     description = (

cognite/neat/rules/models/__init__.py

@@ -0,0 +1,27 @@
+from cognite.neat.rules.models.domain import DomainRules
+from cognite.neat.rules.models.information._rules import InformationRules
+
+from ._base import DataModelType, ExtensionCategory, RoleTypes, SchemaCompleteness, SheetEntity, SheetList
+from .dms._rules import DMSRules
+from .dms._schema import DMSSchema
+
+RULES_PER_ROLE: dict[RoleTypes, type[DomainRules] | type[InformationRules] | type[DMSRules]] = {
+    RoleTypes.domain_expert: DomainRules,
+    RoleTypes.information_architect: InformationRules,
+    RoleTypes.dms_architect: DMSRules,
+}
+
+
+__all__ = [
+    "DomainRules",
+    "InformationRules",
+    "DMSRules",
+    "RULES_PER_ROLE",
+    "DMSSchema",
+    "RoleTypes",
+    "SchemaCompleteness",
+    "ExtensionCategory",
+    "DataModelType",
+    "SheetList",
+    "SheetEntity",
+]

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

@@ -0,0 +1,18 @@
+from ._rules import DMSContainer, DMSMetadata, DMSProperty, DMSRules, DMSView
+from ._rules_input import DMSContainerInput, DMSMetadataInput, DMSPropertyInput, DMSRulesInput, DMSViewInput
+from ._schema import DMSSchema, PipelineSchema
+
+__all__ = [
+    "DMSRules",
+    "DMSSchema",
+    "DMSMetadata",
+    "DMSView",
+    "DMSProperty",
+    "DMSContainer",
+    "PipelineSchema",
+    "DMSRulesInput",
+    "DMSMetadataInput",
+    "DMSViewInput",
+    "DMSPropertyInput",
+    "DMSContainerInput",
+]

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

@@ -0,0 +1,140 @@
+import warnings
+from datetime import datetime
+from typing import cast
+
+from rdflib import Namespace
+
+from cognite.neat.rules import issues
+from cognite.neat.rules.models._base import SheetList
+from cognite.neat.rules.models.data_types import DataType
+from cognite.neat.rules.models.domain import DomainRules
+from cognite.neat.rules.models.entities import (
+    ClassEntity,
+    ContainerEntity,
+    DMSUnknownEntity,
+    ParentClassEntity,
+    ReferenceEntity,
+    UnknownEntity,
+    ViewEntity,
+    ViewPropertyEntity,
+)
+from cognite.neat.rules.models.information._rules import InformationRules
+
+from ._rules import DMSProperty, DMSRules, DMSView
+
+
+class _DMSRulesConverter:
+    def __init__(self, dms: DMSRules):
+        self.dms = dms
+
+    def as_domain_rules(self) -> "DomainRules":
+        raise NotImplementedError("DomainRules not implemented yet")
+
+    def as_information_architect_rules(
+        self,
+        created: datetime | None = None,
+        updated: datetime | None = None,
+        name: str | None = None,
+        namespace: Namespace | None = None,
+    ) -> "InformationRules":
+        from cognite.neat.rules.models.information._rules import (
+            InformationClass,
+            InformationMetadata,
+            InformationProperty,
+            InformationRules,
+        )
+
+        dms = self.dms.metadata
+        prefix = dms.space
+
+        metadata = InformationMetadata(
+            schema_=dms.schema_,
+            prefix=prefix,
+            namespace=namespace or Namespace(f"https://purl.orgl/neat/{prefix}/"),
+            version=dms.version,
+            name=name or dms.name or "Missing name",
+            creator=dms.creator,
+            created=dms.created or created or datetime.now(),
+            updated=dms.updated or updated or datetime.now(),
+        )
+
+        classes = [
+            InformationClass(
+                # we do not want a version in class as we use URI for the class
+                class_=ClassEntity(prefix=view.class_.prefix, suffix=view.class_.suffix),
+                description=view.description,
+                parent=[
+                    # we do not want a version in class as we use URI for the class
+                    ParentClassEntity(prefix=implemented_view.prefix, suffix=implemented_view.suffix)
+                    # We only want parents in the same namespace, parent in a different namespace is a reference
+                    for implemented_view in view.implements or []
+                    if implemented_view.prefix == view.class_.prefix
+                ],
+                reference=self._get_class_reference(view),
+            )
+            for view in self.dms.views
+        ]
+
+        properties: list[InformationProperty] = []
+        value_type: DataType | ClassEntity | str
+        for property_ in self.dms.properties:
+            if isinstance(property_.value_type, DataType):
+                value_type = property_.value_type
+            elif isinstance(property_.value_type, ViewEntity | ViewPropertyEntity):
+                value_type = ClassEntity(
+                    prefix=property_.value_type.prefix,
+                    suffix=property_.value_type.suffix,
+                )
+            elif isinstance(property_.value_type, DMSUnknownEntity):
+                value_type = UnknownEntity()
+            else:
+                raise ValueError(f"Unsupported value type: {property_.value_type.type_}")
+
+            properties.append(
+                InformationProperty(
+                    # Removing version
+                    class_=ClassEntity(suffix=property_.class_.suffix, prefix=property_.class_.prefix),
+                    property_=property_.view_property,
+                    value_type=value_type,
+                    description=property_.description,
+                    min_count=0 if property_.nullable or property_.nullable is None else 1,
+                    max_count=float("inf") if property_.is_list or property_.nullable is None else 1,
+                    reference=self._get_property_reference(property_),
+                )
+            )
+
+        return InformationRules(
+            metadata=metadata,
+            properties=SheetList[InformationProperty](data=properties),
+            classes=SheetList[InformationClass](data=classes),
+            last=self.dms.last.as_information_architect_rules() if self.dms.last else None,
+            reference=self.dms.reference.as_information_architect_rules() if self.dms.reference else None,
+        )
+
+    @classmethod
+    def _get_class_reference(cls, view: DMSView) -> ReferenceEntity | None:
+        parents_other_namespace = [parent for parent in view.implements or [] if parent.prefix != view.class_.prefix]
+        if len(parents_other_namespace) == 0:
+            return None
+        if len(parents_other_namespace) > 1:
+            warnings.warn(
+                issues.dms.MultipleReferenceWarning(
+                    view_id=view.view.as_id(), implements=[v.as_id() for v in parents_other_namespace]
+                ),
+                stacklevel=2,
+            )
+        other_parent = parents_other_namespace[0]
+
+        return ReferenceEntity(prefix=other_parent.prefix, suffix=other_parent.suffix)
+
+    @classmethod
+    def _get_property_reference(cls, property_: DMSProperty) -> ReferenceEntity | None:
+        has_container_other_namespace = property_.container and property_.container.prefix != property_.class_.prefix
+        if not has_container_other_namespace:
+            return None
+        container = cast(ContainerEntity, property_.container)
+        return ReferenceEntity(
+            prefix=container.prefix,
+            suffix=container.suffix,
+            property=property_.container_property,
+        )