cognite-neat 0.88.2__py3-none-any.whl → 0.89.0__py3-none-any.whl

cognite/neat/rules/models/{entities.py → entities/_single_value.py}

@@ -1,9 +1,12 @@
-import re
+import inspect
 import sys
 from abc import ABC, abstractmethod
 from functools import total_ordering
-from typing import Annotated, Any, ClassVar, Generic, TypeVar, cast
+from types import UnionType
+from typing import Any, ClassVar, Generic, Literal, TypeVar, Union, cast, get_args, get_origin
 
+from cognite.client.data_classes.data_modeling import DirectRelationReference
+from cognite.client.data_classes.data_modeling.data_types import UnitReference
 from cognite.client.data_classes.data_modeling.ids import (
     ContainerId,
     DataModelId,
@@ -12,16 +15,12 @@ from cognite.client.data_classes.data_modeling.ids import (
     ViewId,
 )
 from pydantic import (
-    AnyHttpUrl,
     BaseModel,
-    BeforeValidator,
     Field,
-    PlainSerializer,
     model_serializer,
     model_validator,
 )
 
-from cognite.neat.rules.models.data_types import DataType
 from cognite.neat.utils.text import replace_non_alphanumeric_with_underscore
 
 if sys.version_info >= (3, 11):
@@ -31,66 +30,17 @@ else:
     from backports.strenum import StrEnum
     from typing_extensions import Self
 
+from cognite.neat.utils.regex_patterns import SPLIT_ON_COMMA_PATTERN, SPLIT_ON_EQUAL_PATTERN
 
-class EntityTypes(StrEnum):
-    view_non_versioned = "view_non_versioned"
-    subject = "subject"
-    predicate = "predicate"
-    object = "object"
-    class_ = "class"
-    parent_class = "parent_class"
-    property_ = "property"
-    object_property = "ObjectProperty"
-    data_property = "DatatypeProperty"
-    annotation_property = "AnnotationProperty"
-    object_value_type = "object_value_type"
-    data_value_type = "data_value_type"  # these are strings, floats, ...
-    xsd_value_type = "xsd_value_type"
-    dms_value_type = "dms_value_type"
-    dms_node = "dms_node"
-    view = "view"
-    reference_entity = "reference_entity"
-    container = "container"
-    datamodel = "datamodel"
-    undefined = "undefined"
-    multi_value_type = "multi_value_type"
-    asset = "asset"
-    relationship = "relationship"
-
-
-# ALLOWED
-_ALLOWED_PATTERN = r"[^a-zA-Z0-9-_.]"
-
-# FOR PARSING STRINGS:
-_PREFIX_REGEX = r"[a-zA-Z]+[a-zA-Z0-9-_.]*[a-zA-Z0-9]+"
-_SUFFIX_REGEX = r"[a-zA-Z0-9-_.]+[a-zA-Z0-9]|[-_.]*[a-zA-Z0-9]+"
-_VERSION_REGEX = r"[a-zA-Z0-9]([.a-zA-Z0-9_-]{0,41}[a-zA-Z0-9])?"
-_PROPERTY_REGEX = r"[a-zA-Z0-9][a-zA-Z0-9_-]*[a-zA-Z0-9]?"
-_ENTITY_ID_REGEX = rf"{_PREFIX_REGEX}:({_SUFFIX_REGEX})"
-_ENTITY_ID_REGEX_COMPILED = re.compile(rf"^(?P<prefix>{_PREFIX_REGEX}):(?P<suffix>{_SUFFIX_REGEX})$")
-_VERSIONED_ENTITY_REGEX_COMPILED = re.compile(
-    rf"^(?P<prefix>{_PREFIX_REGEX}):(?P<suffix>{_SUFFIX_REGEX})\(version=(?P<version>{_VERSION_REGEX})\)$"
+from ._constants import (
+    _PARSE,
+    ENTITY_PATTERN,
+    EntityTypes,
+    Undefined,
+    Unknown,
+    _UndefinedType,
+    _UnknownType,
 )
-_CLASS_ID_REGEX = rf"(?P<{EntityTypes.class_}>{_ENTITY_ID_REGEX})"
-_CLASS_ID_REGEX_COMPILED = re.compile(rf"^{_CLASS_ID_REGEX}$")
-_PROPERTY_ID_REGEX = rf"\((?P<{EntityTypes.property_}>{_ENTITY_ID_REGEX})\)"
-
-_ENTITY_PATTERN = re.compile(r"^(?P<prefix>.*?):?(?P<suffix>[^(:]*)(\((?P<content>[^)]+)\))?$")
-_MULTI_VALUE_TYPE_PATTERN = re.compile(r"^(?P<types>.*?)(\((?P<content>[^)]+)\))?$")
-
-
-class _UndefinedType(BaseModel): ...
-
-
-class _UnknownType(BaseModel):
-    def __str__(self) -> str:
-        return "#N/A"
-
-
-# This is a trick to make Undefined and Unknown singletons
-Undefined = _UndefinedType()
-Unknown = _UnknownType()
-_PARSE = object()
 
 
 @total_ordering
@@ -108,7 +58,7 @@ class Entity(BaseModel, extra="ignore"):
         elif isinstance(data, str) and data == str(Unknown):
             return UnknownEntity(prefix=Undefined, suffix=Unknown)
         if defaults and isinstance(defaults, dict):
-            # This is trick to pass in default values
+            # This is is a trick to pass in default values
             return cls.model_validate({_PARSE: data, "defaults": defaults})
         else:
             return cls.model_validate(data)
@@ -132,7 +82,7 @@ class Entity(BaseModel, extra="ignore"):
         elif data == str(Unknown):
             raise ValueError(f"Unknown is not allowed for {cls.type_} entity")
 
-        result = cls._parse(data)
+        result = cls._parse(data, defaults)
         output = defaults.copy()
         # Populate by alias
         for field_name, field_ in cls.model_fields.items():
@@ -148,20 +98,29 @@ class Entity(BaseModel, extra="ignore"):
         return str(self)
 
     @classmethod
-    def _parse(cls, raw: str) -> dict:
-        if not (result := _ENTITY_PATTERN.match(raw)):
+    def _parse(cls, raw: str, defaults: dict) -> dict:
+        if not (result := ENTITY_PATTERN.match(raw)):
             return dict(prefix=Undefined, suffix=Unknown)
         prefix = result.group("prefix") or Undefined
         suffix = result.group("suffix")
         content = result.group("content")
         if content is None:
             return dict(prefix=prefix, suffix=suffix)
-        extra_args = dict(pair.strip().split("=") for pair in content.split(","))
-        expected_args = {field_.alias or field_name for field_name, field_ in cls.model_fields.items()}
+        extra_args = dict(SPLIT_ON_EQUAL_PATTERN.split(pair.strip()) for pair in SPLIT_ON_COMMA_PATTERN.split(content))
+        expected_args = {
+            field_.alias or field_name: field_.annotation for field_name, field_ in cls.model_fields.items()
+        }
         for key in list(extra_args):
             if key not in expected_args:
                 # Todo Warning about unknown key
                 del extra_args[key]
+                continue
+            annotation = expected_args[key]
+            if isinstance(annotation, UnionType) or get_origin(annotation) is Union:
+                annotation = get_args(annotation)[0]
+
+            if inspect.isclass(annotation) and issubclass(annotation, Entity):  # type: ignore[arg-type]
+                extra_args[key] = annotation.load(extra_args[key], **defaults)  # type: ignore[union-attr, assignment]
         return dict(prefix=prefix, suffix=suffix, **extra_args)
 
     def dump(self) -> str:
@@ -206,12 +165,15 @@ class Entity(BaseModel, extra="ignore"):
     @property
     def id(self) -> str:
         # We have overwritten the serialization to str, so we need to do it manually
-        model_dump = (
+        model_dump = [
             (field.alias or field_name, v)
             for field_name, field in self.model_fields.items()
             if (v := getattr(self, field_name)) is not None and field_name not in {"prefix", "suffix"}
-        )
-        args = ",".join([f"{k}={v}" for k, v in model_dump])
+        ]
+        if len(model_dump) == 1:
+            args = f"{model_dump[0][0]}={model_dump[0][1]}"
+        else:
+            args = ",".join([f"{k}={v}" for k, v in model_dump])
         if self.prefix == Undefined:
             base_id = str(self.suffix)
         else:
@@ -268,6 +230,15 @@ class UnknownEntity(ClassEntity):
         return str(Unknown)
 
 
+class UnitEntity(Entity):
+    type_: ClassVar[EntityTypes] = EntityTypes.unit
+    prefix: str
+    suffix: str
+
+    def as_reference(self) -> UnitReference:
+        return UnitReference(external_id=f"{self.prefix}:{self.suffix}")
+
+
 class AssetFields(StrEnum):
     externalId = "externalId"
     name = "name"
@@ -293,61 +264,6 @@ class RelationshipEntity(Entity):
 T_ID = TypeVar("T_ID", bound=ContainerId | ViewId | DataModelId | PropertyId | NodeId | None)
 
 
-class MultiValueTypeInfo(BaseModel):
-    type_: ClassVar[EntityTypes] = EntityTypes.multi_value_type
-    types: list[DataType | ClassEntity]
-
-    def __str__(self) -> str:
-        return " | ".join([str(t) for t in self.types])
-
-    @model_serializer(when_used="unless-none", return_type=str)
-    def as_str(self) -> str:
-        return str(self)
-
-    @classmethod
-    def load(cls, data: Any) -> "MultiValueTypeInfo":
-        # already instance of MultiValueTypeInfo
-        if isinstance(data, cls):
-            return data
-
-        # it is a raw string that needs to be parsed
-        elif isinstance(data, str):
-            return cls.model_validate({_PARSE: data})
-
-        # it is dict that needs to be parsed
-        else:
-            return cls.model_validate(data)
-
-    @model_validator(mode="before")
-    def _load(cls, data: Any) -> "dict | MultiValueTypeInfo":
-        if isinstance(data, dict) and _PARSE in data:
-            data = data[_PARSE]
-        elif isinstance(data, dict):
-            return data
-        else:
-            raise ValueError(f"Cannot load {cls.__name__} from {data}")
-
-        result = cls._parse(data)
-        return result
-
-    @classmethod
-    def _parse(cls, raw: str) -> dict:
-        if not (types := [type_.strip() for type_ in raw.split("|")]):
-            return {"types": [UnknownEntity()]}
-        else:
-            return {
-                "types": [
-                    (DataType.load(type_) if DataType.is_data_type(type_) else ClassEntity.load(type_))
-                    for type_ in types
-                ]
-            }
-
-    def set_default_prefix(self, prefix: str):
-        for type_ in self.types:
-            if isinstance(type_, ClassEntity) and type_.prefix is Undefined:
-                type_.prefix = prefix
-
-
 class DMSEntity(Entity, Generic[T_ID], ABC):
     type_: ClassVar[EntityTypes] = EntityTypes.undefined
     prefix: str = Field(alias="space")
@@ -452,33 +368,6 @@ class DMSUnknownEntity(DMSEntity[None]):
         return str(Unknown)
 
 
-class ViewPropertyEntity(DMSVersionedEntity[PropertyId]):
-    type_: ClassVar[EntityTypes] = EntityTypes.property_
-    property_: str = Field(alias="property")
-
-    def as_id(self) -> PropertyId:
-        return PropertyId(
-            source=ViewId(self.space, self.external_id, self.version),
-            property=self.property_,
-        )
-
-    def as_view_id(self) -> ViewId:
-        return ViewId(space=self.space, external_id=self.external_id, version=self.version)
-
-    @classmethod
-    def from_id(cls, id: PropertyId) -> "ViewPropertyEntity":
-        if isinstance(id.source, ContainerId):
-            raise ValueError("Only view source are supported")
-        if id.source.version is None:
-            raise ValueError("Version must be specified")
-        return cls(
-            space=id.source.space,
-            externalId=id.source.external_id,
-            version=id.source.version,
-            property=id.property,
-        )
-
-
 class DataModelEntity(DMSVersionedEntity[DataModelId]):
     type_: ClassVar[EntityTypes] = EntityTypes.datamodel
 
@@ -498,10 +387,40 @@ class DMSNodeEntity(DMSEntity[NodeId]):
     def as_id(self) -> NodeId:
         return NodeId(space=self.space, external_id=self.external_id)
 
+    def as_reference(self) -> DirectRelationReference:
+        return DirectRelationReference(space=self.space, external_id=self.external_id)
+
     @classmethod
     def from_id(cls, id: NodeId) -> "DMSNodeEntity":
         return cls(space=id.space, externalId=id.external_id)
 
+    @classmethod
+    def from_reference(cls, ref: DirectRelationReference) -> "DMSNodeEntity":
+        return cls(space=ref.space, externalId=ref.external_id)
+
+
+class EdgeEntity(DMSEntity[None]):
+    type_: ClassVar[EntityTypes] = EntityTypes.edge
+    prefix: _UndefinedType = Undefined  # type: ignore[assignment]
+    suffix: Literal["edge"] = "edge"
+    edge_type: DMSNodeEntity | None = Field(None, alias="type")
+    properties: ViewEntity | None = None
+    direction: Literal["outwards", "inwards"] = "outwards"
+
+    def as_id(self) -> None:
+        return None
+
+    @classmethod
+    def from_id(cls, id: None) -> Self:
+        return cls()
+
+
+class ReverseConnectionEntity(Entity):
+    type_: ClassVar[EntityTypes] = EntityTypes.reverse
+    prefix: _UndefinedType = Undefined
+    suffix: Literal["reverse"] = "reverse"
+    property_: str = Field(alias="property")
+
 
 class ReferenceEntity(ClassEntity):
     type_: ClassVar[EntityTypes] = EntityTypes.reference_entity
@@ -538,80 +457,3 @@ class ReferenceEntity(ClassEntity):
 
     def as_class_entity(self) -> ClassEntity:
         return ClassEntity(prefix=self.prefix, suffix=self.suffix, version=self.version)
-
-
-def _split_str(v: Any) -> list[str]:
-    if isinstance(v, str):
-        return v.replace(", ", ",").split(",")
-    return v
-
-
-def _join_str(v: list[ClassEntity]) -> str | None:
-    return ",".join([entry.id for entry in v]) if v else None
-
-
-def _generate_cdf_resource_list(v: Any) -> list[AssetEntity | RelationshipEntity]:
-    results = []
-    for item in _split_str(v):
-        if isinstance(item, str):
-            if "relationship" in item.lower():
-                results.append(RelationshipEntity.load(item))
-            elif "asset" in item.lower():
-                results.append(AssetEntity.load(item))  # type: ignore
-            else:
-                raise ValueError(f"Unsupported implementation definition: {item}")
-
-        elif isinstance(item, AssetEntity | RelationshipEntity):
-            results.append(item)
-        else:
-            raise ValueError(f"Unsupported implementation definition: {item}")
-
-    return results  # type: ignore
-
-
-ClassEntityList = Annotated[
-    list[ClassEntity],
-    BeforeValidator(_split_str),
-    PlainSerializer(
-        _join_str,
-        return_type=str,
-        when_used="unless-none",
-    ),
-]
-
-
-CdfResourceEntityList = Annotated[
-    list[AssetEntity | RelationshipEntity],
-    BeforeValidator(_generate_cdf_resource_list),
-    PlainSerializer(
-        _join_str,
-        return_type=str,
-        when_used="unless-none",
-    ),
-]
-
-
-ContainerEntityList = Annotated[
-    list[ContainerEntity],
-    BeforeValidator(_split_str),
-    PlainSerializer(
-        _join_str,
-        return_type=str,
-        when_used="unless-none",
-    ),
-]
-
-ViewEntityList = Annotated[
-    list[ViewEntity],
-    BeforeValidator(_split_str),
-    PlainSerializer(
-        _join_str,
-        return_type=str,
-        when_used="unless-none",
-    ),
-]
-
-URLEntity = Annotated[
-    AnyHttpUrl,
-    PlainSerializer(lambda v: str(v), return_type=str, when_used="unless-none"),
-]

cognite/neat/rules/models/entities/_types.py

@@ -0,0 +1,86 @@
+from typing import Annotated, Any
+
+from pydantic import (
+    AnyHttpUrl,
+    BeforeValidator,
+    PlainSerializer,
+)
+
+from ._single_value import AssetEntity, ClassEntity, ContainerEntity, RelationshipEntity, ViewEntity
+
+
+def _split_str(v: Any) -> list[str]:
+    if isinstance(v, str):
+        return v.replace(", ", ",").split(",")
+    return v
+
+
+def _join_str(v: list[ClassEntity]) -> str | None:
+    return ",".join([entry.id for entry in v]) if v else None
+
+
+def _generate_cdf_resource_list(v: Any) -> list[AssetEntity | RelationshipEntity]:
+    results = []
+    for item in _split_str(v):
+        if isinstance(item, str):
+            if "relationship" in item.lower():
+                results.append(RelationshipEntity.load(item))
+            elif "asset" in item.lower():
+                results.append(AssetEntity.load(item))  # type: ignore
+            else:
+                raise ValueError(f"Unsupported implementation definition: {item}")
+
+        elif isinstance(item, AssetEntity | RelationshipEntity):
+            results.append(item)
+        else:
+            raise ValueError(f"Unsupported implementation definition: {item}")
+
+    return results  # type: ignore
+
+
+ClassEntityList = Annotated[
+    list[ClassEntity],
+    BeforeValidator(_split_str),
+    PlainSerializer(
+        _join_str,
+        return_type=str,
+        when_used="unless-none",
+    ),
+]
+
+
+CdfResourceEntityList = Annotated[
+    list[AssetEntity | RelationshipEntity],
+    BeforeValidator(_generate_cdf_resource_list),
+    PlainSerializer(
+        _join_str,
+        return_type=str,
+        when_used="unless-none",
+    ),
+]
+
+
+ContainerEntityList = Annotated[
+    list[ContainerEntity],
+    BeforeValidator(_split_str),
+    PlainSerializer(
+        _join_str,
+        return_type=str,
+        when_used="unless-none",
+    ),
+]
+
+ViewEntityList = Annotated[
+    list[ViewEntity],
+    BeforeValidator(_split_str),
+    PlainSerializer(
+        _join_str,
+        return_type=str,
+        when_used="unless-none",
+    ),
+]
+
+URLEntity = Annotated[
+    AnyHttpUrl,
+    PlainSerializer(lambda v: str(v), return_type=str, when_used="unless-none"),
+]

cognite/neat/rules/models/{wrapped_entities.py → entities/_wrapped.py}

@@ -9,7 +9,7 @@ from cognite.client import data_modeling as dm
 from cognite.client.data_classes.data_modeling import ContainerId, NodeId
 from pydantic import BaseModel, model_serializer, model_validator
 
-from cognite.neat.rules.models.entities import ContainerEntity, DMSNodeEntity, Entity
+from ._single_value import ContainerEntity, DMSNodeEntity, Entity
 
 
 @total_ordering

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

@@ -1,10 +1,18 @@
 from ._rules import InformationClass, InformationMetadata, InformationProperty, InformationRules
-from ._rules_input import InformationRulesInput
+from ._rules_input import (
+    InformationInputClass,
+    InformationInputMetadata,
+    InformationInputProperty,
+    InformationInputRules,
+)
 
 __all__ = [
     "InformationRules",
     "InformationMetadata",
     "InformationClass",
     "InformationProperty",
-    "InformationRulesInput",
+    "InformationInputRules",
+    "InformationInputMetadata",
+    "InformationInputClass",
+    "InformationInputProperty",
 ]

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

@@ -8,10 +8,8 @@ from pydantic.main import IncEx
 from rdflib import Namespace
 
 from cognite.neat.constants import get_default_prefixes
-from cognite.neat.issues import MultiValueError
-from cognite.neat.rules import issues
-from cognite.neat.rules.issues.spreadsheet import DefaultValueTypeNotProperError
-from cognite.neat.rules.models._base import (
+from cognite.neat.issues.errors import PropertyDefinitionError
+from cognite.neat.rules.models._base_rules import (
     BaseMetadata,
     BaseRules,
     DataModelType,
@@ -36,7 +34,6 @@ from cognite.neat.rules.models._types import (
     VersionType,
 )
 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,
     ClassEntityList,
@@ -49,7 +46,7 @@ from cognite.neat.rules.models.entities import (
 )
 
 if TYPE_CHECKING:
-    from cognite.neat.rules.models import AssetRules, DMSRules
+    from cognite.neat.rules.models import DMSRules
 
 
 if sys.version_info >= (3, 11):
@@ -228,11 +225,12 @@ class InformationProperty(SheetEntity):
                         self.default = self.value_type.python(self.default)
 
                 except Exception:
-                    raise DefaultValueTypeNotProperError(
+                    raise PropertyDefinitionError(
+                        self.class_,
+                        "Class",
                         self.property_,
-                        type(self.default),
-                        str(self.value_type.python),
-                    ).as_exception() from None
+                        f"Default value {self.default} is not of type {self.value_type.python}",
+                    ) from None
         return self
 
     @property
@@ -306,7 +304,7 @@ class InformationRules(BaseRules):
         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)])
+            raise issue_list.as_exception()
         return self
 
     def dump(
@@ -341,17 +339,7 @@ class InformationRules(BaseRules):
             cleaned[reference] = _InformationRulesSerializer(by_alias, prefix).clean(ref_dump, True)
         return cleaned
 
-    def as_domain_rules(self) -> DomainRules:
-        from ._converter import _InformationRulesConverter
-
-        return _InformationRulesConverter(self).as_domain_rules()
-
-    def as_asset_architect_rules(self) -> "AssetRules":
-        from ._converter import _InformationRulesConverter
-
-        return _InformationRulesConverter(self).as_asset_architect_rules()
-
     def as_dms_rules(self) -> "DMSRules":
-        from ._converter import _InformationRulesConverter
+        from cognite.neat.rules.transformers._converters import _InformationRulesConverter
 
         return _InformationRulesConverter(self).as_dms_rules()