cognite-neat 0.123.2__py3-none-any.whl → 0.127.30__py3-none-any.whl

cognite/neat/v0/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.v0.core._data_model._constants import EntityTypes
+from cognite.neat.v0.core._data_model.models.data_types import _XSD_TYPES, DataType
+from cognite.neat.v0.core._data_model.models.entities._constants import _PARSE
+from cognite.neat.v0.core._data_model.models.entities._single_value import ConceptEntity, ConceptualEntity
+from cognite.neat.v0.core._issues.errors._general import NeatValueError
+from cognite.neat.v0.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 → v0/core}/_data_model/models/entities/_single_value.py

@@ -22,8 +22,8 @@ from pydantic import (
     model_validator,
 )
 
-from cognite.neat.core._issues.errors import NeatValueError
-from cognite.neat.core._utils.text import replace_non_alphanumeric_with_underscore
+from cognite.neat.v0.core._issues.errors import NeatValueError
+from cognite.neat.v0.core._utils.text import replace_non_alphanumeric_with_underscore
 
 if sys.version_info >= (3, 11):
     from enum import StrEnum
@@ -32,7 +32,7 @@ else:
     from backports.strenum import StrEnum
     from typing_extensions import Self
 
-from cognite.neat.core._data_model._constants import (
+from cognite.neat.v0.core._data_model._constants import (
     ENTITY_PATTERN,
     SPLIT_ON_COMMA_PATTERN,
     SPLIT_ON_EDGE_ENTITY_ARGS_PATTERN,
@@ -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:
@@ -495,6 +579,13 @@ class EdgeEntity(PhysicalEntity[None]):
     properties: ViewEntity | None = None
     direction: Literal["outwards", "inwards"] = "outwards"
 
+    @field_validator("direction", mode="before")
+    @classmethod
+    def _normalize_direction(cls, value: Any) -> str:
+        if isinstance(value, str):
+            return value.lower()
+        return value
+
     def dump(self, **defaults: Any) -> str:
         # Add default direction
         return super().dump(**defaults, direction="outwards")
@@ -569,3 +660,17 @@ class ContainerIndexEntity(PhysicalEntity[None]):
     @classmethod
     def from_id(cls, id: None) -> Self:
         return cls(suffix="dummy")
+
+
+class ContainerConstraintEntity(PhysicalEntity[None]):
+    type_: ClassVar[EntityTypes] = EntityTypes.container_constraint
+    prefix: _UndefinedType | Literal["uniqueness", "requires"] = Undefined  # type: ignore[assignment]
+    suffix: str
+    require: ContainerEntity | None = None
+
+    def as_id(self) -> None:
+        return None
+
+    @classmethod
+    def from_id(cls, id: None) -> Self:
+        return cls(suffix="dummy")

cognite/neat/{core → v0/core}/_data_model/models/entities/_types.py

@@ -9,6 +9,7 @@ from pydantic import (
 from ._single_value import (
     AssetEntity,
     ConceptEntity,
+    ContainerConstraintEntity,
     ContainerEntity,
     ContainerIndexEntity,
     RelationshipEntity,
@@ -76,6 +77,15 @@ ContainerIndexListType = Annotated[
         when_used="unless-none",
     ),
 ]
+ContainerConstraintListType = Annotated[
+    list[ContainerConstraintEntity],
+    BeforeValidator(_split_str),
+    PlainSerializer(
+        _join_str,
+        return_type=str,
+        when_used="unless-none",
+    ),
+]
 
 ViewEntityList = Annotated[
     list[ViewEntity],

cognite/neat/{core → v0/core}/_data_model/models/mapping/_classic2core.py

@@ -3,12 +3,12 @@ from pathlib import Path
 
 import yaml
 
-from cognite.neat.core._data_model._shared import ImportedDataModel
-from cognite.neat.core._data_model.models.physical import (
+from cognite.neat.v0.core._data_model._shared import ImportedDataModel
+from cognite.neat.v0.core._data_model.models.physical import (
     PhysicalDataModel,
     UnverifiedPhysicalDataModel,
 )
-from cognite.neat.core._issues.errors import NeatValueError
+from cognite.neat.v0.core._issues.errors import NeatValueError
 
 _CLASSIC_TO_CORE_MAPPING = Path(__file__).resolve().parent / "_classic2core.yaml"
 
@@ -19,8 +19,8 @@ def _read_source_file() -> str:
 
 
 def load_classic_to_core_mapping(org_name: str | None, source_space: str, source_version: str) -> PhysicalDataModel:
-    from cognite.neat.core._data_model.importers import DictImporter
-    from cognite.neat.core._data_model.transformers import VerifyPhysicalDataModel
+    from cognite.neat.v0.core._data_model.importers import DictImporter
+    from cognite.neat.v0.core._data_model.transformers import VerifyPhysicalDataModel
 
     raw_str = _read_source_file()
     if org_name is not None:

cognite/neat/{core → v0/core}/_data_model/models/physical/__init__.py

@@ -1,4 +1,4 @@
-from cognite.neat.core._client.data_classes.schema import DMSSchema
+from cognite.neat.v0.core._client.data_classes.schema import DMSSchema
 
 from ._unverified import (
     UnverifiedPhysicalContainer,

cognite/neat/{core → v0/core}/_data_model/models/physical/_exporter.py

@@ -13,20 +13,20 @@ from cognite.client.data_classes.data_modeling.views import (
     ViewPropertyApply,
 )
 
-from cognite.neat.core._client.data_classes.data_modeling import (
+from cognite.neat.v0.core._client.data_classes.data_modeling import (
     ContainerApplyDict,
     NodeApplyDict,
     SpaceApplyDict,
     ViewApplyDict,
 )
-from cognite.neat.core._client.data_classes.schema import DMSSchema
-from cognite.neat.core._constants import (
+from cognite.neat.v0.core._client.data_classes.schema import DMSSchema
+from cognite.neat.v0.core._constants import (
     COGNITE_SPACES,
     DMS_DIRECT_RELATION_LIST_DEFAULT_LIMIT,
     DMS_PRIMITIVE_LIST_DEFAULT_LIMIT,
 )
-from cognite.neat.core._data_model.models.data_types import DataType, Double, Enum, Float
-from cognite.neat.core._data_model.models.entities import (
+from cognite.neat.v0.core._data_model.models.data_types import DataType, Double, Enum, Float, LangString, String
+from cognite.neat.v0.core._data_model.models.entities import (
     ConceptEntity,
     ContainerEntity,
     ContainerIndexEntity,
@@ -41,16 +41,16 @@ from cognite.neat.core._data_model.models.entities import (
     UnitEntity,
     ViewEntity,
 )
-from cognite.neat.core._issues.errors import (
+from cognite.neat.v0.core._issues.errors import (
     NeatTypeError,
     NeatValueError,
     ResourceNotFoundError,
 )
-from cognite.neat.core._issues.warnings import (
+from cognite.neat.v0.core._issues.warnings import (
     NotSupportedWarning,
     PropertyNotFoundWarning,
 )
-from cognite.neat.core._issues.warnings.user_modeling import (
+from cognite.neat.v0.core._issues.warnings.user_modeling import (
     EmptyContainerWarning,
     HasDataFilterOnNoPropertiesViewWarning,
 )
@@ -243,17 +243,21 @@ class _DMSExporter:
             connection = cast(EdgeEntity, prop.connection)
 
             if connection.direction == "inwards" and isinstance(prop.value_type, ViewEntity):
-                edge_type_candidates = outwards_type_by_view_value_type.get((prop.view, prop.value_type), [])
-                if len(edge_type_candidates) == 0:
-                    # Warning in validation, should not have an inwards connection without an outwards connection
-                    edge_type = cls._default_edge_type_from_view_id(prop.view.as_id(), prop_id)
-                elif len(edge_type_candidates) == 1:
-                    edge_type = edge_type_candidates[0]
+                if connection.edge_type is not None:
+                    edge_type = connection.edge_type.as_reference()
                 else:
-                    raise NeatValueError(
-                        f"Cannot infer edge type for {view_id}.{prop_id}, multiple candidates: {edge_type_candidates}."
-                        "Please specify edge type explicitly, i.e., edge(type=<YOUR_TYPE>)."
-                    )
+                    edge_type_candidates = outwards_type_by_view_value_type.get((prop.view, prop.value_type), [])
+                    if len(edge_type_candidates) == 0:
+                        # Warning in validation, should not have an inwards connection without an outwards connection
+                        edge_type = cls._default_edge_type_from_view_id(prop.view.as_id(), prop_id)
+                    elif len(edge_type_candidates) == 1:
+                        edge_type = edge_type_candidates[0]
+                    else:
+                        raise NeatValueError(
+                            f"Cannot infer edge type for {view_id}.{prop_id}, multiple candidates: "
+                            f"{edge_type_candidates}. "
+                            "Please specify edge type explicitly, i.e., edge(type=<YOUR_TYPE>)."
+                        )
                 view_property_id = (prop.view, prop.view_property)
                 edge_types_by_view_property_id[view_property_id] = edge_type
 
@@ -347,6 +351,8 @@ class _DMSExporter:
                             args["max_list_size"] = prop.max_count
                 if isinstance(prop.value_type, Double | Float) and isinstance(prop.value_type.unit, UnitEntity):
                     args["unit"] = prop.value_type.unit.as_reference()
+                if isinstance(prop.value_type, String | LangString) and prop.value_type.max_text_size is not None:
+                    args["max_text_size"] = prop.value_type.max_text_size
                 if isinstance(prop.value_type, Enum):
                     if prop.value_type.collection not in enum_values_by_collection:
                         raise ResourceNotFoundError(
@@ -377,7 +383,8 @@ class _DMSExporter:
             for prop in container_properties:
                 if prop.container_property is not None:
                     for constraint in prop.constraint or []:
-                        uniqueness_properties[constraint].add(prop.container_property)
+                        uniqueness_properties[cast(str, constraint.suffix)].add(prop.container_property)
+
             for constraint_name, properties in uniqueness_properties.items():
                 container.constraints = container.constraints or {}
                 container.constraints[constraint_name] = dm.UniquenessConstraint(properties=list(properties))
@@ -391,9 +398,9 @@ class _DMSExporter:
                 container.indexes = container.indexes or {}
                 index_property_list = [prop_id for prop_id, _ in sorted(properties, key=lambda x: x[1].order or 0)]
                 index_entity = properties[0][1]
-                if index_entity.prefix == "inverted" or (index_entity.prefix is Undefined and is_list):
+                if index_entity.prefix == "inverted" or (index_entity.prefix == Undefined and is_list):
                     container.indexes[index_name] = InvertedIndex(properties=index_property_list)
-                elif index_entity.prefix == "btree" or (index_entity.prefix is Undefined and not is_list):
+                elif index_entity.prefix == "btree" or (index_entity.prefix == Undefined and not is_list):
                     container.indexes[index_name] = BTreeIndex(
                         properties=index_property_list, cursorable=index_entity.cursorable or False
                     )