cognite-neat 0.77.2__py3-none-any.whl → 0.77.4__py3-none-any.whl

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

@@ -1,6 +1,6 @@
 import math
 import sys
-import warnings
+from collections.abc import Callable
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, ClassVar, cast
 
@@ -8,9 +8,9 @@ from pydantic import Field, field_serializer, field_validator, model_serializer,
 from pydantic_core.core_schema import SerializationInfo
 from rdflib import Namespace
 
-import cognite.neat.rules.issues.spreadsheet
 from cognite.neat.constants import PREFIXES
-from cognite.neat.rules import exceptions
+from cognite.neat.rules import exceptions, issues
+from cognite.neat.rules.issues.base import MultiValueError
 from cognite.neat.rules.models._base import (
     BaseMetadata,
     DataModelType,
@@ -44,17 +44,14 @@ 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,
-    Entity,
     EntityTypes,
     ParentClassEntity,
     ParentEntityList,
     ReferenceEntity,
     Undefined,
-    Unknown,
     UnknownEntity,
     URLEntity,
     _UndefinedType,
-    _UnknownType,
 )
 
 if TYPE_CHECKING:
@@ -69,9 +66,10 @@ else:
 
 class InformationMetadata(BaseMetadata):
     role: ClassVar[RoleTypes] = RoleTypes.information_architect
-    data_model_type: DataModelType = Field(DataModelType.solution, alias="dataModelType")
-    schema_: SchemaCompleteness = Field(alias="schema")
+    data_model_type: DataModelType = Field(DataModelType.enterprise, alias="dataModelType")
+    schema_: SchemaCompleteness = Field(SchemaCompleteness.partial, alias="schema")
     extension: ExtensionCategoryType | None = ExtensionCategory.addition
+
     prefix: PrefixType
     namespace: NamespaceType
 
@@ -97,6 +95,8 @@ class InformationMetadata(BaseMetadata):
             "typically information architects are considered as contributors."
         ),
     )
+    license: str | None = None
+    rights: str | None = None
 
     @model_validator(mode="after")
     def extension_none_but_schema_extend(self) -> Self:
@@ -105,6 +105,18 @@ class InformationMetadata(BaseMetadata):
             return self
         return self
 
+    @field_validator("schema_", mode="plain")
+    def as_enum_schema(cls, value: str) -> SchemaCompleteness:
+        return SchemaCompleteness(value)
+
+    @field_validator("extension", mode="plain")
+    def as_enum_extension(cls, value: str) -> ExtensionCategory:
+        return ExtensionCategory(value)
+
+    @field_validator("data_model_type", mode="plain")
+    def as_enum_model_type(cls, value: str) -> DataModelType:
+        return DataModelType(value)
+
 
 class InformationClass(SheetEntity):
     """
@@ -282,77 +294,24 @@ class InformationRules(RuleModel):
         return self
 
     @model_validator(mode="after")
-    def validate_schema_completeness(self) -> Self:
-        # update expected_value_types
-
-        if self.metadata.schema_ == SchemaCompleteness.complete:
-            defined_classes = {str(class_.class_) for class_ in self.classes}
-            referred_classes = {str(property_.class_) for property_ in self.properties} | {
-                str(parent) for class_ in self.classes for parent in class_.parent or []
-            }
-            referred_types = {
-                str(property_.value_type)
-                for property_ in self.properties
-                if isinstance(property_.value_type, Entity)
-                and not isinstance(property_.value_type.suffix, _UnknownType)
-            }
-            if not referred_classes.issubset(defined_classes) or not referred_types.issubset(defined_classes):
-                missing_classes = referred_classes.difference(defined_classes).union(
-                    referred_types.difference(defined_classes)
-                )
-                raise exceptions.IncompleteSchema(missing_classes).to_pydantic_custom_error()
-
+    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 MultiValueError([error for error in issue_list if isinstance(error, issues.NeatValidationError)])
         return self
 
-    @model_validator(mode="after")
-    def validate_class_has_properties_or_parent(self) -> Self:
-        defined_classes = {class_.class_ for class_ in self.classes if class_.reference is None}
-        referred_classes = {property_.class_ for property_ in self.properties if property_.class_.suffix is not Unknown}
-        has_parent_classes = {class_.class_ for class_ in self.classes if class_.parent}
-        missing_classes = defined_classes.difference(referred_classes) - has_parent_classes
-        if missing_classes:
-            warnings.warn(
-                cognite.neat.rules.issues.spreadsheet.ClassNoPropertiesNoParentsWarning(
-                    [missing.versioned_id for missing in missing_classes]
-                ),
-                stacklevel=2,
-            )
-        return self
+    @model_serializer(mode="wrap", when_used="always")
+    def information_rules_serializer(self, handler: Callable, info: SerializationInfo) -> dict[str, Any]:
+        from ._serializer import _InformationRulesSerializer
 
-    @model_serializer(mode="plain", when_used="always")
-    def information_rules_serializer(self, info: SerializationInfo) -> dict[str, Any]:
-        kwargs = vars(info)
-        default_prefix = f"{self.metadata.prefix}:" if self.metadata.prefix else ""
-
-        field_names = ["Class", "Value Type"] if info.by_alias else ["class_", "value_type"]
-        properties = []
-        for prop in self.properties:
-            dumped = prop.model_dump(**kwargs)
-            for field_name in field_names:
-                if value := dumped.get(field_name):
-                    dumped[field_name] = value.removeprefix(default_prefix)
-            properties.append(dumped)
-
-        field_names = ["Class"] if info.by_alias else ["class_"]
-        classes = []
-        parent_name = "Parent Class" if info.by_alias else "parent"
-        for cls in self.classes:
-            dumped = cls.model_dump(**kwargs)
-            for field_name in field_names:
-                if value := dumped.get(field_name):
-                    dumped[field_name] = value.removeprefix(default_prefix)
-            if value := dumped.get(parent_name):
-                dumped[parent_name] = ",".join(
-                    constraint.strip().removeprefix(default_prefix) for constraint in value.split(",")
-                )
-            classes.append(dumped)
-
-        return {
-            "Metadata" if info.by_alias else "metadata": self.metadata.model_dump(**kwargs),
-            "Classes" if info.by_alias else "classes": classes,
-            "Properties" if info.by_alias else "properties": properties,
-            "prefixes": {key: str(value) for key, value in self.prefixes.items()},
-        }
+        dumped = cast(dict[str, Any], handler(self, info))
+        prefix = self.metadata.prefix
+
+        return _InformationRulesSerializer(info, prefix).clean(dumped)
 
     def as_domain_rules(self) -> DomainRules:
         from ._converter import _InformationRulesConverter
@@ -368,9 +327,9 @@ class InformationRules(RuleModel):
         new_self = self.model_copy(deep=True)
         for prop in new_self.properties:
             prop.reference = ReferenceEntity(
-                prefix=prop.class_.prefix
-                if not isinstance(prop.class_.prefix, _UndefinedType)
-                else self.metadata.prefix,
+                prefix=(
+                    prop.class_.prefix if not isinstance(prop.class_.prefix, _UndefinedType) else self.metadata.prefix
+                ),
                 suffix=prop.class_.suffix,
                 version=prop.class_.version,
                 property=prop.property_,
@@ -378,9 +337,9 @@ class InformationRules(RuleModel):
 
         for cls_ in new_self.classes:
             cls_.reference = ReferenceEntity(
-                prefix=cls_.class_.prefix
-                if not isinstance(cls_.class_.prefix, _UndefinedType)
-                else self.metadata.prefix,
+                prefix=(
+                    cls_.class_.prefix if not isinstance(cls_.class_.prefix, _UndefinedType) else self.metadata.prefix
+                ),
                 suffix=cls_.class_.suffix,
                 version=cls_.class_.version,
             )

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

@@ -0,0 +1,266 @@
+from collections.abc import Sequence
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Literal, cast, overload
+
+from rdflib import Namespace
+
+from cognite.neat.rules.models._base import DataModelType, ExtensionCategory, SchemaCompleteness, _add_alias
+from cognite.neat.rules.models.data_types import DataType
+from cognite.neat.rules.models.entities import ClassEntity, ParentClassEntity, Unknown, UnknownEntity
+
+from ._rules import InformationClass, InformationMetadata, InformationProperty, InformationRules
+
+
+@dataclass
+class InformationMetadataInput:
+    schema_: Literal["complete", "partial", "extended"]
+    prefix: str
+    namespace: str
+    version: str
+    creator: str
+    data_model_type: Literal["solution", "enterprise"] = "enterprise"
+    extension: Literal["addition", "reshape", "rebuild"] = "addition"
+    name: str | None = None
+    description: str | None = None
+    created: datetime | str | None = None
+    updated: datetime | str | None = None
+    license: str | None = None
+    rights: str | None = None
+
+    @classmethod
+    def load(cls, data: dict[str, Any] | None) -> "InformationMetadataInput | None":
+        if data is None:
+            return None
+        _add_alias(data, InformationMetadata)
+        return cls(
+            data_model_type=data.get("data_model_type", "enterprise"),
+            extension=data.get("extension", "addition"),
+            schema_=data.get("schema_", "partial"),  # type: ignore[arg-type]
+            version=data.get("version"),  # type: ignore[arg-type]
+            namespace=data.get("namespace"),  # type: ignore[arg-type]
+            prefix=data.get("prefix"),  # type: ignore[arg-type]
+            name=data.get("name"),
+            creator=data.get("creator"),  # type: ignore[arg-type]
+            description=data.get("description"),
+            created=data.get("created"),
+            updated=data.get("updated"),
+            license=data.get("license"),
+            rights=data.get("rights"),
+        )
+
+    def dump(self) -> dict[str, Any]:
+        return dict(
+            dataModelType=DataModelType(self.data_model_type),
+            schema=SchemaCompleteness(self.schema_),
+            extension=ExtensionCategory(self.extension),
+            namespace=Namespace(self.namespace),
+            prefix=self.prefix,
+            version=self.version,
+            name=self.name,
+            creator=self.creator,
+            description=self.description,
+            created=self.created or datetime.now(),
+            updated=self.updated or datetime.now(),
+        )
+
+
+@dataclass
+class InformationPropertyInput:
+    class_: str
+    property_: str
+    value_type: str
+    name: str | None = None
+    description: str | None = None
+    comment: str | None = None
+    min_count: int | None = None
+    max_count: int | float | None = None
+    default: Any | None = None
+    reference: str | None = None
+    match_type: str | None = None
+    rule_type: str | None = None
+    rule: str | None = None
+
+    @classmethod
+    @overload
+    def load(cls, data: None) -> None: ...
+
+    @classmethod
+    @overload
+    def load(cls, data: dict[str, Any]) -> "InformationPropertyInput": ...
+
+    @classmethod
+    @overload
+    def load(cls, data: list[dict[str, Any]]) -> list["InformationPropertyInput"]: ...
+
+    @classmethod
+    def load(
+        cls, data: dict[str, Any] | list[dict[str, Any]] | None
+    ) -> "InformationPropertyInput | list[InformationPropertyInput] | None":
+        if data is None:
+            return None
+        if isinstance(data, list) or (isinstance(data, dict) and isinstance(data.get("data"), list)):
+            items = cast(list[dict[str, Any]], data.get("data") if isinstance(data, dict) else data)
+            return [loaded for item in items if (loaded := cls.load(item)) is not None]
+
+        _add_alias(data, InformationProperty)
+        return cls(
+            class_=data.get("class_"),  # type: ignore[arg-type]
+            property_=data.get("property_"),  # type: ignore[arg-type]
+            name=data.get("name", None),
+            description=data.get("description", None),
+            comment=data.get("comment", None),
+            value_type=data.get("value_type"),  # type: ignore[arg-type]
+            min_count=data.get("min_count", None),
+            max_count=data.get("max_count", None),
+            default=data.get("default", None),
+            reference=data.get("reference", None),
+            match_type=data.get("match_type", None),
+            rule_type=data.get("rule_type", None),
+            rule=data.get("rule", None),
+        )
+
+    def dump(self, default_prefix: str) -> dict[str, Any]:
+        value_type: DataType | ClassEntity | UnknownEntity
+
+        # property holding xsd data type
+        if DataType.is_data_type(self.value_type):
+            value_type = DataType.load(self.value_type)
+
+        # unknown value type
+        elif self.value_type == str(Unknown):
+            value_type = UnknownEntity()
+
+        # property holding link to class
+        else:
+            value_type = ClassEntity.load(self.value_type, prefix=default_prefix)
+
+        return {
+            "Class": ClassEntity.load(self.class_, prefix=default_prefix),
+            "Property": self.property_,
+            "Name": self.name,
+            "Description": self.description,
+            "Comment": self.comment,
+            "Value Type": value_type,
+            "Min Count": self.min_count,
+            "Max Count": self.max_count,
+            "Default": self.default,
+            "Reference": self.reference,
+            "Match Type": self.match_type,
+            "Rule Type": self.rule_type,
+            "Rule": self.rule,
+        }
+
+
+@dataclass
+class InformationClassInput:
+    class_: str
+    name: str | None = None
+    description: str | None = None
+    comment: str | None = None
+    parent: str | None = None
+    reference: str | None = None
+    match_type: str | None = None
+
+    @classmethod
+    @overload
+    def load(cls, data: None) -> None: ...
+
+    @classmethod
+    @overload
+    def load(cls, data: dict[str, Any]) -> "InformationClassInput": ...
+
+    @classmethod
+    @overload
+    def load(cls, data: list[dict[str, Any]]) -> list["InformationClassInput"]: ...
+
+    @classmethod
+    def load(
+        cls, data: dict[str, Any] | list[dict[str, Any]] | None
+    ) -> "InformationClassInput | list[InformationClassInput] | None":
+        if data is None:
+            return None
+        if isinstance(data, list) or (isinstance(data, dict) and isinstance(data.get("data"), list)):
+            items = cast(list[dict[str, Any]], data.get("data") if isinstance(data, dict) else data)
+            return [loaded for item in items if (loaded := cls.load(item)) is not None]
+        _add_alias(data, InformationClass)
+        return cls(
+            class_=data.get("class_"),  # type: ignore[arg-type]
+            name=data.get("name", None),
+            description=data.get("description", None),
+            comment=data.get("comment", None),
+            parent=data.get("parent", None),
+            reference=data.get("reference", None),
+            match_type=data.get("match_type", None),
+        )
+
+    def dump(self, default_prefix: str) -> dict[str, Any]:
+        return {
+            "Class": ClassEntity.load(self.class_, prefix=default_prefix),
+            "Name": self.name,
+            "Description": self.description,
+            "Comment": self.comment,
+            "Reference": self.reference,
+            "Match Type": self.match_type,
+            "Parent Class": (
+                [ParentClassEntity.load(parent, prefix=default_prefix) for parent in self.parent.split(",")]
+                if self.parent
+                else None
+            ),
+        }
+
+
+@dataclass
+class InformationRulesInput:
+    metadata: InformationMetadataInput
+    properties: Sequence[InformationPropertyInput]
+    classes: Sequence[InformationClassInput]
+    last: "InformationRulesInput | InformationRules | None" = None
+    reference: "InformationRulesInput | InformationRules | None" = None
+
+    @classmethod
+    @overload
+    def load(cls, data: dict[str, Any]) -> "InformationRulesInput": ...
+
+    @classmethod
+    @overload
+    def load(cls, data: None) -> None: ...
+
+    @classmethod
+    def load(cls, data: dict | None) -> "InformationRulesInput | None":
+        if data is None:
+            return None
+        _add_alias(data, InformationRules)
+
+        return cls(
+            metadata=InformationMetadataInput.load(data.get("metadata")),  # type: ignore[arg-type]
+            properties=InformationPropertyInput.load(data.get("properties")),  # type: ignore[arg-type]
+            classes=InformationClassInput.load(data.get("classes")),  # type: ignore[arg-type]
+            last=InformationRulesInput.load(data.get("last")),
+            reference=InformationRulesInput.load(data.get("reference")),
+        )
+
+    def as_rules(self) -> InformationRules:
+        return InformationRules.model_validate(self.dump())
+
+    def dump(self) -> dict[str, Any]:
+        default_prefix = self.metadata.prefix
+        reference: dict[str, Any] | None = None
+        if isinstance(self.reference, InformationRulesInput):
+            reference = self.reference.dump()
+        elif isinstance(self.reference, InformationRules):
+            # We need to load through the InformationRulesInput to set the correct default space and version
+            reference = InformationRulesInput.load(self.reference.model_dump()).dump()
+        last: dict[str, Any] | None = None
+        if isinstance(self.last, InformationRulesInput):
+            last = self.last.dump()
+        elif isinstance(self.last, InformationRules):
+            # We need to load through the InformationRulesInput to set the correct default space and version
+            last = InformationRulesInput.load(self.last.model_dump()).dump()
+        return dict(
+            Metadata=self.metadata.dump(),
+            Properties=[prop.dump(default_prefix) for prop in self.properties],
+            Classes=[class_.dump(default_prefix) for class_ in self.classes],
+            Last=last,
+            Reference=reference,
+        )

cognite/neat/rules/models/information/_serializer.py

@@ -0,0 +1,85 @@
+from typing import Any, ClassVar, cast
+
+from pydantic_core.core_schema import SerializationInfo
+
+from cognite.neat.rules.models import InformationRules
+from cognite.neat.rules.models.information import InformationClass, InformationProperty
+
+
+class _InformationRulesSerializer:
+    # These are the fields that need to be cleaned from the default space and version
+    PROPERTIES_FIELDS: ClassVar[list[str]] = ["class_", "value_type"]
+    CLASSES_FIELDS: ClassVar[list[str]] = ["class_"]
+
+    def __init__(self, info: SerializationInfo, default_prefix: str) -> None:
+        self.default_prefix = f"{default_prefix}:"
+
+        self.properties_fields = self.PROPERTIES_FIELDS
+        self.classes_fields = self.CLASSES_FIELDS
+
+        self.prop_name = "properties"
+        self.class_name = "classes"
+        self.metadata_name = "metadata"
+        self.class_parent = "parent"
+
+        self.prop_property = "property_"
+        self.prop_class = "class_"
+
+        if info.by_alias:
+            self.properties_fields = [
+                InformationProperty.model_fields[field].alias or field for field in self.properties_fields
+            ]
+            self.classes_fields = [InformationClass.model_fields[field].alias or field for field in self.classes_fields]
+            self.prop_name = InformationRules.model_fields[self.prop_name].alias or self.prop_name
+            self.class_name = InformationRules.model_fields[self.class_name].alias or self.class_name
+            self.class_parent = InformationClass.model_fields[self.class_parent].alias or self.class_parent
+            self.metadata_name = InformationRules.model_fields[self.metadata_name].alias or self.metadata_name
+
+            self.prop_property = InformationProperty.model_fields[self.prop_property].alias or self.prop_property
+            self.prop_class = InformationProperty.model_fields[self.prop_class].alias or self.prop_class
+
+        if isinstance(info.exclude, dict):
+            # Just for happy mypy
+            exclude = cast(dict, info.exclude)
+            self.metadata_exclude = exclude.get("metadata", set()) or set()
+            self.exclude_classes = exclude.get("classes", {}).get("__all__", set()) or set()
+            self.exclude_properties = exclude.get("properties", {}).get("__all__", set())
+            self.exclude_top = {k for k, v in exclude.items() if not v}
+        else:
+            self.exclude_top = set(info.exclude or {})
+            self.exclude_properties = set()
+            self.exclude_classes = set()
+            self.metadata_exclude = set()
+
+    def clean(self, dumped: dict[str, Any]) -> dict[str, Any]:
+        # Sorting to get a deterministic order
+        dumped[self.prop_name] = sorted(
+            dumped[self.prop_name]["data"], key=lambda p: (p[self.prop_class], p[self.prop_property])
+        )
+        dumped[self.class_name] = sorted(dumped[self.class_name]["data"], key=lambda v: v[self.prop_class])
+
+        for prop in dumped[self.prop_name]:
+            for field_name in self.properties_fields:
+                if value := prop.get(field_name):
+                    prop[field_name] = value.removeprefix(self.default_prefix)
+
+            if self.exclude_properties:
+                for field in self.exclude_properties:
+                    prop.pop(field, None)
+
+        for class_ in dumped[self.class_name]:
+            for field_name in self.classes_fields:
+                if value := class_.get(field_name):
+                    class_[field_name] = value.removeprefix(self.default_prefix)
+
+            if value := class_.get(self.class_parent):
+                class_[self.class_parent] = ",".join(
+                    parent.strip().removeprefix(self.default_prefix) for parent in value.split(",")
+                )
+
+        if self.metadata_exclude:
+            for field in self.metadata_exclude:
+                dumped[self.metadata_name].pop(field, None)
+        for field in self.exclude_top:
+            dumped.pop(field, None)
+        return dumped