cognite-neat 0.123.26__py3-none-any.whl → 0.123.28__py3-none-any.whl

cognite/neat/_version.py

@@ -1,2 +1,2 @@
-__version__ = "0.123.26"
+__version__ = "0.123.28"
 __engine__ = "^2.0.4"

cognite/neat/core/_data_model/_constants.py

@@ -43,6 +43,10 @@ class EntityTypes(StrEnum):
     prefix = "prefix"
     space = "space"
     container_index = "container_index"
+    concept_restriction = "conceptRestriction"
+    value_constraint = "valueConstraint"
+    cardinality_constraint = "cardinalityConstraint"
+    named_individual = "named_individual"
 
 
 def get_reserved_words(

cognite/neat/core/_data_model/models/conceptual/_unverified.py

@@ -100,8 +100,8 @@ class UnverifiedConceptualProperty(UnverifiedComponent[ConceptualProperty]):
 
     def dump(self, default_prefix: str, **kwargs) -> dict[str, Any]:  # type: ignore
         output = super().dump()
-        output["Concept"] = ConceptEntity.load(self.concept, prefix=default_prefix)
-        output["Value Type"] = load_value_type(self.value_type, default_prefix)
+        output["Concept"] = ConceptEntity.load(self.concept, prefix=default_prefix, return_on_failure=True)
+        output["Value Type"] = load_value_type(self.value_type, default_prefix, return_on_failure=True)
         return output
 
     def copy(self, update: dict[str, Any], default_prefix: str) -> "UnverifiedConceptualProperty":
@@ -135,10 +135,16 @@ class UnverifiedConcept(UnverifiedComponent[Concept]):
         parent: list[ConceptEntity] | None = None
         if isinstance(self.implements, str):
             self.implements = self.implements.strip()
-            parent = [ConceptEntity.load(parent, prefix=default_prefix) for parent in self.implements.split(",")]
+            parent = [
+                ConceptEntity.load(parent_str, prefix=default_prefix, return_on_failure=True)
+                for parent_str in self.implements.split(",")
+            ]
         elif isinstance(self.implements, list):
-            parent = [ConceptEntity.load(parent_, prefix=default_prefix) for parent_ in self.implements]
-        output["Concept"] = ConceptEntity.load(self.concept, prefix=default_prefix)
+            parent = [
+                ConceptEntity.load(parent_str, prefix=default_prefix, return_on_failure=True)
+                for parent_str in self.implements
+            ]
+        output["Concept"] = ConceptEntity.load(self.concept, prefix=default_prefix, return_on_failure=True)
         output["Implements"] = parent
         return output
 

cognite/neat/core/_data_model/models/entities/__init__.py

@@ -1,6 +1,7 @@
 from ._constants import Undefined, Unknown
 from ._loaders import load_connection, load_dms_value_type, load_value_type
 from ._multi_value import MultiValueTypeInfo
+from ._restrictions import ConceptPropertyCardinalityConstraint, ConceptPropertyValueConstraint, parse_restriction
 from ._single_value import (
     AssetEntity,
     AssetFields,
@@ -31,6 +32,8 @@ __all__ = [
     "CdfResourceEntityList",
     "ClassEntityList",
     "ConceptEntity",
+    "ConceptPropertyCardinalityConstraint",
+    "ConceptPropertyValueConstraint",
     "ConceptualEntity",
     "ContainerEntity",
     "ContainerEntityList",
@@ -61,4 +64,5 @@ __all__ = [
     "load_connection",
     "load_dms_value_type",
     "load_value_type",
+    "parse_restriction",
 ]

cognite/neat/core/_data_model/models/entities/_loaders.py

@@ -1,4 +1,4 @@
-from typing import Literal
+from typing import Literal, overload
 
 from cognite.neat.core._data_model.models.data_types import DataType
 from cognite.neat.core._issues.errors import NeatTypeError
@@ -15,10 +15,38 @@ from ._single_value import (
 )
 
 
+@overload
 def load_value_type(
     raw: str | MultiValueTypeInfo | DataType | ConceptEntity | UnknownEntity,
     default_prefix: str,
-) -> MultiValueTypeInfo | DataType | ConceptEntity | UnknownEntity:
+    return_on_failure: Literal[False] = False,
+) -> MultiValueTypeInfo | DataType | ConceptEntity | UnknownEntity: ...
+
+
+@overload
+def load_value_type(
+    raw: str | MultiValueTypeInfo | DataType | ConceptEntity | UnknownEntity,
+    default_prefix: str,
+    return_on_failure: Literal[True],
+) -> MultiValueTypeInfo | DataType | ConceptEntity | UnknownEntity | None | str: ...
+
+
+def load_value_type(
+    raw: str | MultiValueTypeInfo | DataType | ConceptEntity | UnknownEntity,
+    default_prefix: str,
+    return_on_failure: Literal[True, False] = False,
+) -> MultiValueTypeInfo | DataType | ConceptEntity | UnknownEntity | None | str:
+    """
+    Loads a value type from a raw string or entity.
+
+    Args:
+        raw: The raw value to load.
+        default_prefix: The default prefix to use if not specified in the raw value.
+        return_on_failure: If True, returns the raw value on parsing failure instead of raising an error.
+
+    Returns:
+        The loaded value type entity, or the raw value if loading fails and `return_on_failure` is True.
+    """
     if isinstance(raw, MultiValueTypeInfo | DataType | ConceptEntity | UnknownEntity):
         return raw
     elif isinstance(raw, str):
@@ -37,16 +65,47 @@ def load_value_type(
 
         # property holding link to class
         else:
-            return ConceptEntity.load(raw, prefix=default_prefix)
+            return ConceptEntity.load(raw, prefix=default_prefix, return_on_failure=return_on_failure)
     else:
         raise NeatTypeError(f"Invalid value type: {type(raw)}")
 
 
+@overload
+def load_dms_value_type(
+    raw: str | DataType | ViewEntity | PhysicalUnknownEntity,
+    default_space: str,
+    default_version: str,
+    return_on_failure: Literal[False],
+) -> DataType | ViewEntity | PhysicalUnknownEntity: ...
+
+
+@overload
+def load_dms_value_type(
+    raw: str | DataType | ViewEntity | PhysicalUnknownEntity,
+    default_space: str,
+    default_version: str,
+    return_on_failure: Literal[True],
+) -> DataType | ViewEntity | PhysicalUnknownEntity | str: ...
+
+
 def load_dms_value_type(
     raw: str | DataType | ViewEntity | PhysicalUnknownEntity,
     default_space: str,
     default_version: str,
-) -> DataType | ViewEntity | PhysicalUnknownEntity:
+    return_on_failure: Literal[True, False] = False,
+) -> DataType | ViewEntity | PhysicalUnknownEntity | str:
+    """
+    Loads a value type from a raw string or entity in the context of a data modeling service
+
+    Args:
+        raw: The raw value to load.
+        default_space: The default space to use if not specified in the raw value.
+        default_version: The default version to use if not specified in the raw value.
+        return_on_failure: If True, returns the raw value on parsing failure instead of raising an error.
+
+    Returns:
+        The loaded value type entity, or the raw value if loading fails and `return_on_failure` is True.
+    """
     if isinstance(raw, DataType | ViewEntity | PhysicalUnknownEntity):
         return raw
     elif isinstance(raw, str):
@@ -55,21 +114,42 @@ def load_dms_value_type(
         elif raw == str(Unknown):
             return PhysicalUnknownEntity()
         else:
-            return ViewEntity.load(raw, space=default_space, version=default_version)
+            return ViewEntity.load(
+                raw, space=default_space, version=default_version, return_on_failure=return_on_failure
+            )
     raise NeatTypeError(f"Invalid value type: {type(raw)}")
 
 
+@overload
+def load_connection(
+    raw: Literal["direct"] | ReverseConnectionEntity | EdgeEntity | str | None,
+    default_space: str,
+    default_version: str,
+    return_on_failure: Literal[False] = False,
+) -> Literal["direct"] | ReverseConnectionEntity | EdgeEntity | None: ...
+
+
+@overload
+def load_connection(
+    raw: Literal["direct"] | ReverseConnectionEntity | EdgeEntity | str | None,
+    default_space: str,
+    default_version: str,
+    return_on_failure: Literal[True],
+) -> Literal["direct"] | ReverseConnectionEntity | EdgeEntity | None | str: ...
+
+
 def load_connection(
     raw: Literal["direct"] | ReverseConnectionEntity | EdgeEntity | str | None,
     default_space: str,
     default_version: str,
-) -> Literal["direct"] | ReverseConnectionEntity | EdgeEntity | None:
+    return_on_failure: Literal[True, False] = False,
+) -> Literal["direct"] | ReverseConnectionEntity | EdgeEntity | None | str:
     if isinstance(raw, str) and raw.lower() == "direct":
         return "direct"  # type: ignore[return-value]
     elif isinstance(raw, EdgeEntity | ReverseConnectionEntity) or raw is None:
         return raw  # type: ignore[return-value]
     elif isinstance(raw, str) and raw.startswith("edge"):
-        return EdgeEntity.load(raw, space=default_space, version=default_version)  # type: ignore[return-value]
+        return EdgeEntity.load(raw, space=default_space, version=default_version, return_on_failure=return_on_failure)  # type: ignore[return-value]
     elif isinstance(raw, str) and raw.startswith("reverse"):
-        return ReverseConnectionEntity.load(raw)  # type: ignore[return-value]
+        return ReverseConnectionEntity.load(raw, return_on_failure=return_on_failure)  # type: ignore[return-value]
     raise NeatTypeError(f"Invalid connection: {type(raw)}")

cognite/neat/core/_data_model/models/entities/_restrictions.py

@@ -0,0 +1,230 @@
+import re
+import sys
+from abc import ABC
+from typing import Any, ClassVar, Final, Literal, TypeVar, cast, get_args
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
+from rdflib import Literal as RDFLiteral
+from rdflib import URIRef
+
+from cognite.neat.core._data_model._constants import EntityTypes
+from cognite.neat.core._data_model.models.data_types import _XSD_TYPES, DataType
+from cognite.neat.core._data_model.models.entities._constants import _PARSE
+from cognite.neat.core._data_model.models.entities._single_value import ConceptEntity, ConceptualEntity
+from cognite.neat.core._issues.errors._general import NeatValueError
+from cognite.neat.core._utils.rdf_ import remove_namespace_from_uri
+
+if sys.version_info <= (3, 11):
+    from typing_extensions import Self
+else:
+    from typing import Self
+
+
+ValueConstraints = Literal["allValuesFrom", "someValuesFrom", "hasValue"]
+CardinalityConstraints = Literal["minCardinality", "maxCardinality", "cardinality", "qualifiedCardinality"]
+
+
+# Constants for regex patterns - more maintainable
+PROPERTY_PATTERN: Final[str] = r"[a-zA-Z0-9._~?@!$&'*+,;=%-]+"
+VALUE_PATTERN: Final[str] = r".+"
+CARDINALITY_VALUE_PATTERN: Final[str] = r"\d+"
+ON_PATTERN: Final[str] = r"[^(]*"
+
+VALUE_CONSTRAINT_REGEX = re.compile(
+    rf"^{EntityTypes.value_constraint}:(?P<property>{PROPERTY_PATTERN})\((?P<constraint>{'|'.join(get_args(ValueConstraints))}),(?P<value>{VALUE_PATTERN})\)$"
+)
+
+CARDINALITY_CONSTRAINT_REGEX = re.compile(
+    rf"^{EntityTypes.cardinality_constraint}:(?P<property>{PROPERTY_PATTERN})\((?P<constraint>{'|'.join(get_args(CardinalityConstraints))}),(?P<value>{CARDINALITY_VALUE_PATTERN})(?:,(?P<on>{ON_PATTERN}))?\)$"
+)
+
+
+class NamedIndividualEntity(ConceptualEntity):
+    type_: ClassVar[EntityTypes] = EntityTypes.named_individual
+
+    @model_validator(mode="after")
+    def reset_prefix(self) -> Self:
+        self.prefix = "ni"
+        return self
+
+
+class ConceptPropertyRestriction(ABC, BaseModel):
+    model_config: ClassVar[ConfigDict] = ConfigDict(
+        str_strip_whitespace=True,
+        arbitrary_types_allowed=True,
+        strict=False,
+        extra="ignore",
+    )
+    type_: ClassVar[EntityTypes] = EntityTypes.concept_restriction
+    property_: str
+
+    @classmethod
+    def load(cls: "type[T_ConceptPropertyRestriction]", data: Any, **defaults: Any) -> "T_ConceptPropertyRestriction":
+        if isinstance(data, cls):
+            return data
+        elif not isinstance(data, str):
+            raise ValueError(f"Cannot load {cls.__name__} from {data}")
+
+        return cls.model_validate({_PARSE: data, "defaults": defaults})
+
+    @model_validator(mode="before")
+    def _load(cls, data: Any) -> dict:
+        defaults = {}
+        if isinstance(data, dict) and _PARSE in data:
+            defaults = data.get("defaults", {})
+            data = data[_PARSE]
+        if isinstance(data, dict):
+            data.update(defaults)
+            return data
+
+        if not isinstance(data, str):
+            raise ValueError(f"Cannot load {cls.__name__} from {data}")
+
+        return cls._parse(data, defaults)
+
+    @classmethod
+    def _parse(cls, data: str, defaults: dict) -> dict:
+        raise NotImplementedError(f"{cls.__name__} must implement _parse method")
+
+    def dump(self) -> str:
+        return self.__str__()
+
+    def as_tuple(self) -> tuple[str, ...]:
+        # We haver overwritten the serialization to str, so we need to do it manually
+        extra: tuple[str, ...] = tuple(
+            [
+                str(v or "")
+                for field_name in self.model_fields.keys()
+                if (v := getattr(self, field_name)) and field_name not in {"property_"}
+            ]
+        )
+
+        return self.property_, *extra
+
+    def __lt__(self, other: object) -> bool:
+        if not isinstance(other, ConceptPropertyRestriction):
+            return NotImplemented
+        return self.as_tuple() < other.as_tuple()
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, ConceptPropertyRestriction):
+            return NotImplemented
+        return self.as_tuple() == other.as_tuple()
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+
+T_ConceptPropertyRestriction = TypeVar("T_ConceptPropertyRestriction", bound="ConceptPropertyRestriction")
+
+
+class ConceptPropertyValueConstraint(ConceptPropertyRestriction):
+    type_: ClassVar[EntityTypes] = EntityTypes.value_constraint
+    constraint: ValueConstraints
+    value: RDFLiteral | ConceptEntity | NamedIndividualEntity
+
+    @field_validator("value")
+    def validate_value(cls, value: Any) -> Any:
+        if isinstance(value, RDFLiteral) and value.datatype is None:
+            raise NeatValueError("RDFLiteral must have a datatype set, which must be one of the XSD types.")
+        return value
+
+    def __str__(self) -> str:
+        value_str = (
+            f"{self.value.value}^^{remove_namespace_from_uri(cast(URIRef, self.value.datatype))}"
+            if isinstance(self.value, RDFLiteral)
+            else str(self.value)
+        )
+        return f"{self.type_}:{self.property_}({self.constraint},{value_str})"
+
+    @classmethod
+    def _parse(cls, data: str, defaults: dict) -> dict:
+        if not (result := VALUE_CONSTRAINT_REGEX.match(data)):
+            raise NeatValueError(f"Invalid value constraint format: {data}")
+
+        property_ = result.group("property")
+        constraint = result.group("constraint")
+        raw_value = result.group("value")
+
+        value: NamedIndividualEntity | RDFLiteral | ConceptEntity
+        # scenario 1: NamedIndividual as value restriction
+        if raw_value.startswith("ni:"):
+            value = NamedIndividualEntity.load(raw_value)
+        # scenario 2: Datatype as value restriction
+        elif "^^" in raw_value:
+            if len(value_components := raw_value.split("^^")) == 2 and value_components[1] in _XSD_TYPES:
+                value = RDFLiteral(value_components[0], datatype=DataType.load(value_components[1]).as_xml_uri_ref())
+            else:
+                raise NeatValueError(f"Invalid value format for datatype: {raw_value}")
+
+        # scenario 3: ConceptEntity as value restriction
+        else:
+            value = ConceptEntity.load(raw_value, **defaults)
+
+        return dict(property_=property_, constraint=constraint, value=value)
+
+
+class ConceptPropertyCardinalityConstraint(ConceptPropertyRestriction):
+    type_: ClassVar[EntityTypes] = EntityTypes.cardinality_constraint
+    constraint: CardinalityConstraints
+    value: int = Field(ge=0)
+    on: DataType | ConceptEntity | None = None
+
+    def __str__(self) -> str:
+        on_str = f",{self.on}" if self.on else ""
+        return f"{self.type_}:{self.property_}({self.constraint},{self.value}{on_str})"
+
+    @classmethod
+    def _parse(cls, data: str, defaults: dict) -> dict:
+        if not (result := CARDINALITY_CONSTRAINT_REGEX.match(data)):
+            raise NeatValueError(f"Invalid cardinality constraint format: {data}")
+
+        property_ = result.group("property")
+        constraint = result.group("constraint")
+        value = result.group("value")
+        on = result.group("on")
+        if on:
+            if on in _XSD_TYPES:
+                on = DataType.load(on)
+            else:
+                on = cast(ConceptEntity, ConceptEntity.load(on, **defaults))
+
+        return dict(property_=property_, constraint=constraint, value=value, on=on)
+
+
+def parse_restriction(data: str, **defaults: Any) -> ConceptPropertyRestriction:
+    """Parse a string to create either a value or cardinality restriction.
+
+    Args:
+        data: String representation of the restriction
+        **defaults: Default values to use when parsing
+
+    Returns:
+        Either a ConceptPropertyValueConstraint or ConceptPropertyCardinalityConstraint
+
+    Raises:
+        NeatValueError: If the string cannot be parsed as either restriction type
+    """
+    # Check for value constraint pattern first (more specific)
+    if VALUE_CONSTRAINT_REGEX.match(data):
+        try:
+            return ConceptPropertyValueConstraint.load(data, **defaults)
+        except Exception as e:
+            raise NeatValueError(f"Failed to parse value constraint: {data}") from e
+
+    # Check for cardinality constraint pattern
+    if CARDINALITY_CONSTRAINT_REGEX.match(data):
+        try:
+            return ConceptPropertyCardinalityConstraint.load(data, **defaults)
+        except Exception as e:
+            raise NeatValueError(f"Failed to parse cardinality constraint: {data}") from e
+
+    # If neither pattern matches, provide a clear error
+    raise NeatValueError(
+        f"Invalid restriction format: {data}. "
+        f"Expected format: '{EntityTypes.value_constraint}:property(constraint,value)' "
+        f"or '{EntityTypes.cardinality_constraint}:property(constraint,value[,on])'"
+    )
+
+
+T_ConceptRestriction = TypeVar("T_ConceptRestriction", bound=ConceptPropertyRestriction)

cognite/neat/core/_data_model/models/entities/_single_value.py

@@ -59,7 +59,13 @@ class ConceptualEntity(BaseModel, extra="ignore"):
 
     @classmethod
     @overload
-    def load(cls: "type[T_Entity]", data: Any, strict: Literal[True], **defaults: Any) -> "T_Entity": ...
+    def load(
+        cls: "type[T_Entity]",
+        data: Any,
+        strict: Literal[True],
+        return_on_failure: Literal[False] = False,
+        **defaults: Any,
+    ) -> "T_Entity": ...
 
     @classmethod
     @overload
@@ -67,25 +73,59 @@ class ConceptualEntity(BaseModel, extra="ignore"):
         cls: "type[T_Entity]",
         data: Any,
         strict: Literal[False] = False,
+        return_on_failure: Literal[False] = False,
         **defaults: Any,
     ) -> "T_Entity | UnknownEntity": ...
 
     @classmethod
-    def load(cls: "type[T_Entity]", data: Any, strict: bool = False, **defaults: Any) -> "T_Entity | UnknownEntity":
+    @overload
+    def load(
+        cls: "type[T_Entity]",
+        data: Any,
+        strict: Literal[False] = False,
+        return_on_failure: Literal[True] = True,
+        **defaults: Any,
+    ) -> "T_Entity | Any": ...
+
+    @classmethod
+    @overload
+    def load(
+        cls: "type[T_Entity]",
+        data: Any,
+        strict: Literal[True] = True,
+        return_on_failure: Literal[True] = True,
+        **defaults: Any,
+    ) -> "T_Entity | Any": ...
+
+    @classmethod
+    def load(
+        cls: "type[T_Entity]", data: Any, strict: bool = False, return_on_failure: bool = False, **defaults: Any
+    ) -> "T_Entity | UnknownEntity | Any":
+        """Loads an entity from a string or dict representation.
+
+        Args:
+            data: The data to load the entity from. Can be a string or a dict.
+            strict: If True, will raise an error if the data is "unknown".
+            return_on_failure: If True, will return the input data if loading fails.
+                This is used when you want to defer error handling to a later stage.
+            defaults: Default values to use when loading the entity. These will be used if the corresponding
+        """
         if isinstance(data, cls):
             return data
         elif isinstance(data, str) and data == str(Unknown):
             if strict:
                 raise NeatValueError(f"Failed to load entity {data!s}")
             return UnknownEntity(prefix=Undefined, suffix=Unknown)
-        if defaults and isinstance(defaults, dict):
-            # This is a trick to pass in default values
-            try:
+        try:
+            if defaults and isinstance(defaults, dict):
+                # This is a trick to pass in default values
                 return cls.model_validate({_PARSE: data, "defaults": defaults})
-            except ValueError:
-                raise
-        else:
-            return cls.model_validate(data)
+            else:
+                return cls.model_validate(data)
+        except ValueError:
+            if return_on_failure:
+                return data
+            raise
 
     @model_validator(mode="before")
     def _load(cls, data: Any) -> "dict | ConceptualEntity":
@@ -342,7 +382,13 @@ class PhysicalEntity(ConceptualEntity, Generic[T_ID], ABC):
 
     @classmethod  # type: ignore[override]
     @overload
-    def load(cls: "type[T_DMSEntity]", data: Any, strict: Literal[True], **defaults: Any) -> "T_DMSEntity": ...
+    def load(
+        cls: "type[T_DMSEntity]",
+        data: Any,
+        strict: Literal[True],
+        return_on_failure: Literal[False] = False,
+        **defaults: Any,
+    ) -> "T_DMSEntity": ...
 
     @classmethod
     @overload
@@ -350,18 +396,56 @@ class PhysicalEntity(ConceptualEntity, Generic[T_ID], ABC):
         cls: "type[T_DMSEntity]",
         data: Any,
         strict: Literal[False] = False,
+        return_on_failure: Literal[False] = False,
         **defaults: Any,
     ) -> "T_DMSEntity | PhysicalUnknownEntity": ...
 
     @classmethod
+    @overload
     def load(
-        cls: "type[T_DMSEntity]", data: Any, strict: bool = False, **defaults: Any
-    ) -> "T_DMSEntity | PhysicalUnknownEntity":  # type: ignore
+        cls: "type[T_DMSEntity]",
+        data: Any,
+        strict: Literal[False] = False,
+        return_on_failure: Literal[True] = True,
+        **defaults: Any,
+    ) -> "T_DMSEntity | Any": ...
+
+    @classmethod
+    @overload
+    def load(
+        cls: "type[T_DMSEntity]",
+        data: Any,
+        strict: Literal[True] = True,
+        return_on_failure: Literal[True] = True,
+        **defaults: Any,
+    ) -> "T_DMSEntity | Any": ...
+
+    @classmethod
+    def load(
+        cls: "type[T_DMSEntity]",
+        data: Any,
+        strict: Literal[True, False] = False,
+        return_on_failure: Literal[True, False] = False,
+        **defaults: Any,
+    ) -> "T_DMSEntity | PhysicalUnknownEntity | Any":
+        """Loads a DMS entity from a string or dict representation.
+
+        Args:
+            data: The data to load the entity from. Can be a string or a dict.
+            strict: If True, will raise an error if the data is "unknown".
+            return_on_failure: If True, will return the input data if loading fails.
+                This is used when you want to defer error handling to a later stage.
+            defaults: Default values to use when loading the entity. These will be used if the corresponding
+                fields are missing in the input data.
+
+        """
         if isinstance(data, str) and data == str(Unknown):
             if strict:
                 raise NeatValueError(f"Failed to load entity {data!s}")
             return PhysicalUnknownEntity.from_id(None)
-        return cast(T_DMSEntity, super().load(data, **defaults))
+        if isinstance(data, UnknownEntity):
+            return PhysicalUnknownEntity.from_id(None)
+        return cast(T_DMSEntity, super().load(data, strict=False, return_on_failure=return_on_failure, **defaults))
 
     @property
     def space(self) -> str:

cognite/neat/core/_data_model/models/physical/_unverified.py

@@ -3,7 +3,7 @@ import sys
 import warnings
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Any, Literal
+from typing import Any, Literal, overload
 
 import pandas as pd
 from cognite.client import data_modeling as dm
@@ -161,19 +161,23 @@ class UnverifiedPhysicalProperty(UnverifiedComponent[PhysicalProperty]):
 
     def dump(self, default_space: str, default_version: str) -> dict[str, Any]:  # type: ignore[override]
         output = super().dump()
-        output["View"] = ViewEntity.load(self.view, space=default_space, version=default_version)
-        output["Value Type"] = load_dms_value_type(self.value_type, default_space, default_version)
-        output["Connection"] = load_connection(self.connection, default_space, default_version)
+        output["View"] = ViewEntity.load(
+            self.view, space=default_space, version=default_version, return_on_failure=True
+        )
+        output["Value Type"] = load_dms_value_type(
+            self.value_type, default_space, default_version, return_on_failure=True
+        )
+        output["Connection"] = load_connection(self.connection, default_space, default_version, return_on_failure=True)
         output["Container"] = (
-            ContainerEntity.load(self.container, space=default_space, version=default_version)
+            ContainerEntity.load(self.container, space=default_space, version=default_version, return_on_failure=True)
             if self.container
             else None
         )
         if isinstance(self.index, ContainerIndexEntity) or (isinstance(self.index, str) and "," not in self.index):
-            output["Index"] = [ContainerIndexEntity.load(self.index)]
+            output["Index"] = [ContainerIndexEntity.load(self.index, return_on_failure=True)]
         elif isinstance(self.index, str):
             output["Index"] = [
-                ContainerIndexEntity.load(index.strip())
+                ContainerIndexEntity.load(index.strip(), return_on_failure=True)
                 for index in SPLIT_ON_COMMA_PATTERN.split(self.index)
                 if index.strip()
             ]
@@ -185,13 +189,11 @@ class UnverifiedPhysicalProperty(UnverifiedComponent[PhysicalProperty]):
                 elif isinstance(index, str):
                     index_list.extend(
                         [
-                            ContainerIndexEntity.load(idx.strip())
+                            ContainerIndexEntity.load(idx.strip(), return_on_failure=True)
                             for idx in SPLIT_ON_COMMA_PATTERN.split(index)
                             if idx.strip()
                         ]
                     )
-                elif isinstance(index, str):
-                    index_list.append(ContainerIndexEntity.load(index.strip()))
                 else:
                     raise TypeError(f"Unexpected type for index: {type(index)}")
             output["Index"] = index_list
@@ -257,16 +259,29 @@ class UnverifiedPhysicalContainer(UnverifiedComponent[PhysicalContainer]):
 
     def dump(self, default_space: str) -> dict[str, Any]:  # type: ignore[override]
         output = super().dump()
-        output["Container"] = self.as_entity_id(default_space)
+        output["Container"] = self.as_entity_id(default_space, return_on_failure=True)
         output["Constraint"] = (
-            [ContainerEntity.load(constraint.strip(), space=default_space) for constraint in self.constraint.split(",")]
+            [
+                ContainerEntity.load(constraint.strip(), space=default_space, return_on_failure=True)
+                for constraint in self.constraint.split(",")
+            ]
             if self.constraint
             else None
         )
         return output
 
-    def as_entity_id(self, default_space: str) -> ContainerEntity:
-        return ContainerEntity.load(self.container, strict=True, space=default_space)
+    @overload
+    def as_entity_id(self, default_space: str, return_on_failure: Literal[False] = False) -> ContainerEntity: ...
+
+    @overload
+    def as_entity_id(self, default_space: str, return_on_failure: Literal[True]) -> ContainerEntity | str: ...
+
+    def as_entity_id(
+        self, default_space: str, return_on_failure: Literal[True, False] = False
+    ) -> ContainerEntity | str:
+        return ContainerEntity.load(
+            self.container, strict=True, space=default_space, return_on_failure=return_on_failure
+        )
 
     @classmethod
     def from_container(cls, container: dm.ContainerApply) -> "UnverifiedPhysicalContainer":
@@ -306,19 +321,51 @@ class UnverifiedPhysicalView(UnverifiedComponent[PhysicalView]):
 
     def dump(self, default_space: str, default_version: str) -> dict[str, Any]:  # type: ignore[override]
         output = super().dump()
-        output["View"] = self.as_entity_id(default_space, default_version)
-        output["Implements"] = self._load_implements(default_space, default_version)
+        output["View"] = self.as_entity_id(default_space, default_version, return_on_failure=True)
+        output["Implements"] = self._load_implements(default_space, default_version, return_on_failure=True)
         return output
 
-    def as_entity_id(self, default_space: str, default_version: str) -> ViewEntity:
-        return ViewEntity.load(self.view, strict=True, space=default_space, version=default_version)
+    @overload
+    def as_entity_id(
+        self, default_space: str, default_version: str, return_on_failure: Literal[False] = False
+    ) -> ViewEntity: ...
+
+    @overload
+    def as_entity_id(
+        self, default_space: str, default_version: str, return_on_failure: Literal[True]
+    ) -> ViewEntity | str: ...
+
+    def as_entity_id(
+        self, default_space: str, default_version: str, return_on_failure: Literal[True, False] = False
+    ) -> ViewEntity | str:
+        return ViewEntity.load(
+            self.view, strict=True, space=default_space, version=default_version, return_on_failure=return_on_failure
+        )
 
-    def _load_implements(self, default_space: str, default_version: str) -> list[ViewEntity] | None:
+    @overload
+    def _load_implements(
+        self, default_space: str, default_version: str, return_on_failure: Literal[False] = False
+    ) -> list[ViewEntity] | None: ...
+
+    @overload
+    def _load_implements(
+        self, default_space: str, default_version: str, return_on_failure: Literal[True]
+    ) -> list[ViewEntity | str] | None: ...
+
+    def _load_implements(
+        self, default_space: str, default_version: str, return_on_failure: Literal[True, False] = False
+    ) -> list[ViewEntity] | list[ViewEntity | str] | None:
         self.implements = self.implements.strip() if self.implements else None
 
         return (
             [
-                ViewEntity.load(implement, strict=True, space=default_space, version=default_version)
+                ViewEntity.load(
+                    implement,
+                    strict=True,
+                    space=default_space,
+                    version=default_version,
+                    return_on_failure=return_on_failure,
+                )
                 for implement in self.implements.split(",")
             ]
             if self.implements
@@ -361,7 +408,7 @@ class UnverifiedPhysicalNodeType(UnverifiedComponent[PhysicalNodeType]):
 
     def dump(self, default_space: str, **_) -> dict[str, Any]:  # type: ignore
         output = super().dump()
-        output["Node"] = DMSNodeEntity.load(self.node, space=default_space)
+        output["Node"] = DMSNodeEntity.load(self.node, space=default_space, return_on_failure=True)
         return output
 
 

cognite/neat/core/_issues/errors/_wrapper.py

@@ -20,7 +20,11 @@ class SpreadsheetError(NeatError, ValueError, ABC):
         spreadsheet_name = cast(str, location[0])
         if spreadsheet_name not in ERROR_CLS_BY_SPREADSHEET_NAME:
             # This happens for the metadata sheet, which are individual fields
-            return MetadataValueError(error, field_name=spreadsheet_name)
+            if spreadsheet_name == "Metadata" and len(location) >= 2 and isinstance(location[1], str):
+                field_name = cast(str, location[1])
+            else:
+                field_name = spreadsheet_name
+            return MetadataValueError(error, field_name=field_name)
 
         error_cls = ERROR_CLS_BY_SPREADSHEET_NAME[spreadsheet_name]
         row, column = cast(tuple[int, str], location[2:4])

{cognite_neat-0.123.26.dist-info → cognite_neat-0.123.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 0.123.26
+Version: 0.123.28
 Summary: Knowledge graph transformation
 Project-URL: Documentation, https://cognite-neat.readthedocs-hosted.com/
 Project-URL: Homepage, https://cognite-neat.readthedocs-hosted.com/
@@ -18,7 +18,7 @@ Requires-Dist: jsonpath-python<2.0.0,>=1.0.6
 Requires-Dist: mixpanel<5.0.0,>=4.10.1
 Requires-Dist: networkx<4.0.0,>=3.4.2
 Requires-Dist: openpyxl<4.0.0,>=3.0.10
-Requires-Dist: packaging<25.0,>=22.0
+Requires-Dist: packaging>=22.0
 Requires-Dist: pandas<3.0.0,>=1.5.3
 Requires-Dist: pydantic<3.0.0,>=2.0.0
 Requires-Dist: pyvis<1.0.0,>=0.3.2

{cognite_neat-0.123.26.dist-info → cognite_neat-0.123.28.dist-info}/RECORD

@@ -1,5 +1,5 @@
 cognite/neat/__init__.py,sha256=12StS1dzH9_MElqxGvLWrNsxCJl9Hv8A2a9D0E5OD_U,193
-cognite/neat/_version.py,sha256=ZRJQU5AqGl89hbyhyolzPHb6kKhu67DqV9zYl0ab7Nw,47
+cognite/neat/_version.py,sha256=6seCV2thSh0iPLMJ5f4Ba6srBIKclOMKbKjgQpVgAiA,47
 cognite/neat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/core/_config.py,sha256=WT1BS8uADcFvGoUYOOfwFOVq_VBl472TisdoA3wLick,280
@@ -19,7 +19,7 @@ cognite/neat/core/_client/data_classes/neat_sequence.py,sha256=QZWSfWnwk6KlYJvsI
 cognite/neat/core/_client/data_classes/schema.py,sha256=SpkBGbC2SUJG38Ixf1vYJINI66i_OZaT03q4XKRtK54,25067
 cognite/neat/core/_client/data_classes/statistics.py,sha256=GU-u41cOTig0Y5pYhW5KqzCsuAUIX9tOmdizMEveYuw,4487
 cognite/neat/core/_data_model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cognite/neat/core/_data_model/_constants.py,sha256=ssiOprhd4bamglQnLTNjmqYn9mCBW-VOUbn08qDBbsM,5857
+cognite/neat/core/_data_model/_constants.py,sha256=37lvnq3UZu4bPSzjRRThXJGdvaxmA7KJzWL0YysYBs8,6040
 cognite/neat/core/_data_model/_shared.py,sha256=at3-TT6pkdwtsjuz94P1lj1W7dO6_Sb3nQ3JSDBNLCY,2088
 cognite/neat/core/_data_model/analysis/__init__.py,sha256=v3hSfz7AEEqcmdjL71I09tP8Hl-gPZYOiDYMp_CW4vg,70
 cognite/neat/core/_data_model/analysis/_base.py,sha256=VT1orVf0xSSZrKnJoc-cJR1F1mtMn9Ybjk7UDO71aFA,24448
@@ -53,14 +53,15 @@ cognite/neat/core/_data_model/models/_import_contexts.py,sha256=LAQbgwTbyIAY3at2
 cognite/neat/core/_data_model/models/_types.py,sha256=70E8fiLdZkVF2sDUGPuDhzXNA5niVECkVDI7YN0NF60,5488
 cognite/neat/core/_data_model/models/data_types.py,sha256=uQ_u9KxCetLjxo-VtFzOXSxQuuf97Kg-9lfTTGzY6hc,10150
 cognite/neat/core/_data_model/models/conceptual/__init__.py,sha256=9A6myEV8s0-LqdXejaljqPj8S0pIpUL75rNdRDZzyR8,585
-cognite/neat/core/_data_model/models/conceptual/_unverified.py,sha256=VswgnTSjSCRzBX3z5HvintBGaWBPexxIs-7z7S4J57c,6298
+cognite/neat/core/_data_model/models/conceptual/_unverified.py,sha256=2Ju_LJS0xH8Ao-AxZMLwAZwHjg6ITyn4tBwTfzy2Wic,6524
 cognite/neat/core/_data_model/models/conceptual/_validation.py,sha256=CF1jYALTCQFAr5KUwplAzOLdxJGknIeJo-HpxVZsgMY,13859
 cognite/neat/core/_data_model/models/conceptual/_verified.py,sha256=BUB4Ur4kpBoWiwTf57tjxJ2l0tDTSbY7zGrg1g0yVNQ,13716
-cognite/neat/core/_data_model/models/entities/__init__.py,sha256=UsW-_6fwd-TW0WcnShPKf40h75l1elVn80VurUwRAic,1567
+cognite/neat/core/_data_model/models/entities/__init__.py,sha256=qXrnTygYBgu4iE-ehNsHwmZ89pm9pTfU_Qe9rAq-ldg,1789
 cognite/neat/core/_data_model/models/entities/_constants.py,sha256=GXRzVfArwxF3C67VCkzy0JWTZRkRJUYXBQaaecrqcWc,351
-cognite/neat/core/_data_model/models/entities/_loaders.py,sha256=PkrVtGlZWYLvAVIRABrgVSgkMvJYpBqdrHBfz-H0Ut8,2783
+cognite/neat/core/_data_model/models/entities/_loaders.py,sha256=vYRHID2SoseyJuzO4sdjjeWaRnv774SdKz9fCeuHTHU,5703
 cognite/neat/core/_data_model/models/entities/_multi_value.py,sha256=4507L7dr_CL4vo1En6EyMiHhUDOWPTDVR1aYZns6S38,2792
-cognite/neat/core/_data_model/models/entities/_single_value.py,sha256=DO_u8dLLD8xabVZFXilZELv_Fzs6dcMs6msoszw32iY,21034
+cognite/neat/core/_data_model/models/entities/_restrictions.py,sha256=inztyR2EskFK9cYAdm39GbnjAod7Zmg0TL9NI0ZRleM,8925
+cognite/neat/core/_data_model/models/entities/_single_value.py,sha256=HWANjeBNDo_o3s3oHxRWsxtidvo3d40GObcm7H_7hKo,23753
 cognite/neat/core/_data_model/models/entities/_types.py,sha256=MqrCovqI_nvpMB4UqiUk4eUlKANvr8P7wr8k3y8lXlQ,2183
 cognite/neat/core/_data_model/models/entities/_wrapped.py,sha256=hOvdyxCNFgv1UdfaasviKnbEN4yN09Iip0ggQiaXgB4,7993
 cognite/neat/core/_data_model/models/mapping/__init__.py,sha256=T68Hf7rhiXa7b03h4RMwarAmkGnB-Bbhc1H07b2PyC4,100
@@ -68,7 +69,7 @@ cognite/neat/core/_data_model/models/mapping/_classic2core.py,sha256=FRDpYP_CX-C
 cognite/neat/core/_data_model/models/mapping/_classic2core.yaml,sha256=ei-nuivNWVW9HmvzDBKIPF6ZdgaMq64XHw_rKm0CMxg,22584
 cognite/neat/core/_data_model/models/physical/__init__.py,sha256=ONE_xLw1cxfw88rICG_RtbjCYUZm8yS2kBQ4Di3EGnA,987
 cognite/neat/core/_data_model/models/physical/_exporter.py,sha256=DPOytV-sIzpGJtfDEfi7G4RWnSCVNRLWe1KzY26ewmc,30083
-cognite/neat/core/_data_model/models/physical/_unverified.py,sha256=VyI-JULAu6kHJygUclDPH1JYjhf_XcO58tI9BkXORC0,18430
+cognite/neat/core/_data_model/models/physical/_unverified.py,sha256=8Sg0-tfSJ6glc5h1yNDlY29sajAOv3xoi9j-Q-Md6ZY,20116
 cognite/neat/core/_data_model/models/physical/_validation.py,sha256=AuBAecOTAVRbGh9VXZ6W91HsU7-B75ko7oaxlX4Mmqw,41140
 cognite/neat/core/_data_model/models/physical/_verified.py,sha256=4_7XUj6-x74DhL8qe-duXhlNnq6ANmShB7UpICjbQW4,26783
 cognite/neat/core/_data_model/transformers/__init__.py,sha256=N6yRBplAkrwwxoTAre_1BE_fdSZL5jihr7xTQjW3KnM,1876
@@ -130,7 +131,7 @@ cognite/neat/core/_issues/errors/_external.py,sha256=AaKwO5-AvX01d7Hd83vqYl1qNmM
 cognite/neat/core/_issues/errors/_general.py,sha256=QEgTp_bvzGjmpRtr09Lj_SBeD9IVdql5_JmP02P7PfM,1391
 cognite/neat/core/_issues/errors/_properties.py,sha256=ZR2_j-TkxT8Zn5NGMNNOuKQ_bKeciaMOGZkRKg1YCvw,2924
 cognite/neat/core/_issues/errors/_resources.py,sha256=lBK65tJZMhV3z3_xi8zJeo7Nt_agXsOklH_RPKQu28s,4002
-cognite/neat/core/_issues/errors/_wrapper.py,sha256=clhuSwUuHy-FQXQopFIQRY8c_NZM5u-QB9ncoc6Hrbo,2320
+cognite/neat/core/_issues/errors/_wrapper.py,sha256=8kJXp9ONNrP7BvXAr8CUicoN4K_9SToR0Iwde3lja24,2533
 cognite/neat/core/_issues/warnings/__init__.py,sha256=3MQS_elyRD3SG3iEWMWLRJDabth7upT3oX4WD0xxOh4,3263
 cognite/neat/core/_issues/warnings/_external.py,sha256=w-1R7ea6DXTIWqwlwMMjY0YxKDMSJ8gKAbp_nIIM1AI,1324
 cognite/neat/core/_issues/warnings/_general.py,sha256=_6dAFaMz-LIv7GsBBIBq2d-kmbuxVXKvU4jZeb7tjAo,972
@@ -195,7 +196,7 @@ cognite/neat/session/engine/__init__.py,sha256=D3MxUorEs6-NtgoICqtZ8PISQrjrr4dvc
 cognite/neat/session/engine/_import.py,sha256=1QxA2_EK613lXYAHKQbZyw2yjo5P9XuiX4Z6_6-WMNQ,169
 cognite/neat/session/engine/_interface.py,sha256=3W-cYr493c_mW3P5O6MKN1xEQg3cA7NHR_ev3zdF9Vk,533
 cognite/neat/session/engine/_load.py,sha256=g52uYakQM03VqHt_RDHtpHso1-mFFifH5M4T2ScuH8A,5198
-cognite_neat-0.123.26.dist-info/METADATA,sha256=_X-TDE3Cg0RJyvXEA2xzG6Dld67JV1-p7VDXuqDkFFw,9172
-cognite_neat-0.123.26.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cognite_neat-0.123.26.dist-info/licenses/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
-cognite_neat-0.123.26.dist-info/RECORD,,
+cognite_neat-0.123.28.dist-info/METADATA,sha256=UScQChiQFnF4EpPSGPtFyHZ-JgQuiIiPMlRA_CUHLdA,9166
+cognite_neat-0.123.28.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cognite_neat-0.123.28.dist-info/licenses/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
+cognite_neat-0.123.28.dist-info/RECORD,,