cognite-neat 0.123.8__tar.gz → 0.123.10__tar.gz

{cognite_neat-0.123.8 → cognite_neat-0.123.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 0.123.8
+Version: 0.123.10
 Summary: Knowledge graph transformation
 Project-URL: Documentation, https://cognite-neat.readthedocs-hosted.com/
 Project-URL: Homepage, https://cognite-neat.readthedocs-hosted.com/

cognite_neat-0.123.10/cognite/neat/_version.py

@@ -0,0 +1,2 @@
+__version__ = "0.123.10"
+__engine__ = "^2.0.4"

{cognite_neat-0.123.8 → cognite_neat-0.123.10}/cognite/neat/core/_data_model/_constants.py

@@ -111,12 +111,8 @@ PHYSICAL_PROPERTY_ID_COMPLIANCE_REGEX = (
     rf"(?!^({'|'.join(get_reserved_words('property'))})$)"
     r"(^[a-zA-Z][a-zA-Z0-9_]{0,253}[a-zA-Z0-9]?$)"
 )
-CONCEPT_ID_COMPLIANCE_REGEX = (
-    rf"(?!^({'|'.join(get_reserved_words('concept'))})$)"
-    r"(^[a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
-)
+CONCEPT_ID_COMPLIANCE_REGEX = r"^[a-zA-Z0-9._~?@!$&'*+,;=%-]+$"
 
-INFORMATION_PROPERTY_ID_COMPLIANCE_REGEX = r"^(\*)|(?!^(Property|property)$)(^[a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
 VERSION_COMPLIANCE_REGEX = r"^[a-zA-Z0-9]([.a-zA-Z0-9_-]{0,41}[a-zA-Z0-9])?$"
 
 
@@ -156,7 +152,7 @@ class _Patterns:
 
     @cached_property
     def conceptual_property_id_compliance(self) -> re.Pattern[str]:
-        return re.compile(INFORMATION_PROPERTY_ID_COMPLIANCE_REGEX)
+        return re.compile(CONCEPT_ID_COMPLIANCE_REGEX)
 
     @cached_property
     def version_compliance(self) -> re.Pattern[str]:

{cognite_neat-0.123.8 → cognite_neat-0.123.10}/cognite/neat/core/_data_model/models/conceptual/_validation.py

@@ -46,7 +46,7 @@ class ConceptualValidation:
         self._parent_concept_defined()
         self._referenced_classes_exist()
         self._referenced_value_types_exist()
-        self._regex_compliance_with_dms()
+        self._regex_compliance_with_physical_data_model()
 
         return self.issue_list
 
@@ -180,7 +180,7 @@ class ConceptualValidation:
                     )
                 )
 
-    def _regex_compliance_with_dms(self) -> None:
+    def _regex_compliance_with_physical_data_model(self) -> None:
         """Check regex compliance with DMS of properties, classes and value types."""
 
         for prop_ in self._properties:
@@ -239,7 +239,7 @@ class ConceptualValidation:
                     ResourceRegexViolationWarning(
                         concepts.concept,
                         "Concept",
-                        "Concepts sheet, Class column",
+                        "Concepts sheet, Concept column",
                         PATTERNS.view_id_compliance.pattern,
                     )
                 )

{cognite_neat-0.123.8 → cognite_neat-0.123.10}/cognite/neat/core/_data_model/models/physical/_validation.py

@@ -1,6 +1,7 @@
 import warnings
 from collections import Counter, defaultdict
 from collections.abc import Mapping
+from dataclasses import dataclass
 from functools import lru_cache
 
 from cognite.client import data_modeling as dm
@@ -24,12 +25,14 @@ from cognite.neat.core._constants import (
 from cognite.neat.core._data_model.models.data_types import DataType
 from cognite.neat.core._data_model.models.entities import ContainerEntity, RawFilter
 from cognite.neat.core._data_model.models.entities._single_value import (
+    ContainerIndexEntity,
     ViewEntity,
 )
 from cognite.neat.core._issues import IssueList, NeatError
 from cognite.neat.core._issues.errors import (
     CDFMissingClientError,
     PropertyDefinitionDuplicatedError,
+    PropertyInvalidDefinitionError,
     PropertyMappingDuplicatedError,
     PropertyNotFoundError,
     ResourceDuplicatedError,
@@ -55,6 +58,21 @@ from cognite.neat.core._utils.text import humanize_collection
 from ._verified import PhysicalDataModel, PhysicalProperty
 
 
+@dataclass
+class _ContainerPropertyIndex:
+    """This is a helper class used in the indices validation
+
+    Args:
+        location: The index of the property in the properties list.
+        property_: The physical property associated with the container.
+        index: The index entity that defines the container property.
+    """
+
+    location: int
+    property_: PhysicalProperty
+    index: ContainerIndexEntity
+
+
 class PhysicalValidation:
     """This class does all the validation of the physical data model that
     have dependencies between components."""
@@ -145,6 +163,7 @@ class PhysicalValidation:
         all_properties_by_ids = {**ref_properties_by_ids, **properties_by_ids}
         view_properties_by_id = self._as_view_properties_by_id(properties_by_ids)
         parents_view_ids_by_child_id = self._parent_view_ids_by_child_id(all_views_by_id)
+        container_properties_by_id = self._create_container_properties_by_id()
 
         issue_list = IssueList()
 
@@ -154,7 +173,8 @@ class PhysicalValidation:
         # Neat DMS classes Validation
         # These are errors that can only happen due to the format of the Neat DMS classes
         issue_list.extend(self._validate_raw_filter())
-        issue_list.extend(self._consistent_container_properties())
+        issue_list.extend(self._consistent_container_properties(container_properties_by_id))
+        issue_list.extend(self._valid_composite_container_indices(container_properties_by_id))
         issue_list.extend(self._validate_value_type_existence())
         issue_list.extend(
             self._validate_property_referenced_views_and_containers_exists(all_views_by_id, all_containers_by_id)
@@ -320,13 +340,27 @@ class PhysicalValidation:
             parents_by_view[view_id] = get_parents(view_id)
         return parents_by_view
 
-    def _consistent_container_properties(self) -> IssueList:
+    def _create_container_properties_by_id(
+        self,
+    ) -> dict[tuple[ContainerEntity, str], list[tuple[int, PhysicalProperty]]]:
+        """Create a mapping of container properties with their location in the properties list.
+
+        Returns:
+            dict[tuple[ContainerEntity, str], list[tuple[int, PhysicalProperty]]]: A dictionary where the key is a tuple
+                of (ContainerEntity, property name) and the value is a list of tuples of (int, PhysicalProperty) where
+                int is the index of the property in the properties list and PhysicalProperty is the property itself.
+        """
         container_properties_by_id: dict[tuple[ContainerEntity, str], list[tuple[int, PhysicalProperty]]] = defaultdict(
             list
         )
         for prop_no, prop in enumerate(self._properties):
             if prop.container and prop.container_property:
                 container_properties_by_id[(prop.container, prop.container_property)].append((prop_no, prop))
+        return container_properties_by_id
+
+    def _consistent_container_properties(
+        self, container_properties_by_id: dict[tuple[ContainerEntity, str], list[tuple[int, PhysicalProperty]]]
+    ) -> IssueList:
         properties_sheet = self._read_info_by_spreadsheet.get("Properties")
         errors = IssueList()
         for (container, prop_name), properties in container_properties_by_id.items():
@@ -392,11 +426,11 @@ class PhysicalValidation:
                     )
                 )
             index_definitions = {
-                ",".join([index.suffix for index in prop.index]) for _, prop in properties if prop.index is not None
+                ",".join([str(index) for index in prop.index]) for _, prop in properties if prop.index is not None
             }
             if len(index_definitions) > 1:
                 errors.append(
-                    PropertyDefinitionDuplicatedError[dm.ContainerId](
+                    PropertyDefinitionDuplicatedError(
                         container_id,
                         "container",
                         prop_name,
@@ -422,6 +456,104 @@ class PhysicalValidation:
 
         return errors
 
+    def _valid_composite_container_indices(
+        self, container_properties_by_id: dict[tuple[ContainerEntity, str], list[tuple[int, PhysicalProperty]]]
+    ) -> IssueList:
+        """Validate that the indices on the container properties are valid."""
+        index_properties_by_container_index: dict[tuple[ContainerEntity, str], list[_ContainerPropertyIndex]] = (
+            defaultdict(list)
+        )
+        for (container, _), properties in container_properties_by_id.items():
+            for row_no, prop in properties:
+                for index in prop.index or []:
+                    index_properties_by_container_index[(container, index.suffix)].append(
+                        _ContainerPropertyIndex(row_no, prop, index)
+                    )
+
+        properties_sheet_info = self._read_info_by_spreadsheet.get("Properties")
+        errors = IssueList()
+        for (container, _), index_properties in index_properties_by_container_index.items():
+            if len(index_properties) <= 1:
+                # If there is only one property in the index, this is already validated in the field_validator
+                # of the PhysicalProperty class. This validation is only for composite indices.
+                continue
+            container_id = container.as_id()
+            row_numbers = tuple([index_prop.location for index_prop in index_properties])
+            if properties_sheet_info:
+                row_numbers = tuple([properties_sheet_info.adjusted_row_number(row_no) for row_no in row_numbers])
+
+            if order_missing_error := self._validate_container_indices_has_order(
+                index_properties, row_numbers, container_id
+            ):
+                errors.append(order_missing_error)
+            same_order_errors = self._validate_container_indices_same_order(index_properties, row_numbers, container_id)
+            errors.extend(same_order_errors)
+        return errors
+
+    @staticmethod
+    def _validate_container_indices_has_order(
+        index_properties: list[_ContainerPropertyIndex], row_numbers: tuple[int, ...], container_id: dm.ContainerId
+    ) -> PropertyInvalidDefinitionError | None:
+        property_names: list[str] = []
+        indices: list[ContainerIndexEntity] = []
+        for prop_index in index_properties:
+            if prop_index.index.order is None:
+                property_names.append(prop_index.property_.view_property)
+                indices.append(prop_index.index)
+
+        if not property_names:
+            return None
+
+        if len(set(property_names)) == 1:
+            # If this is the same property, this is not a composite index, but a poorly defined single property
+            # index. This will be caught by the PropertyDefinitionDuplicatedError.
+            return None
+
+        properties_str = humanize_collection(property_names)
+        fixed_indices = [str(index.model_copy(update={"order": no})) for no, index in enumerate(indices, 1)]
+        message = (
+            "You must specify the order when using a composite index. "
+            f"For example {humanize_collection(fixed_indices)}."
+        )
+        return PropertyInvalidDefinitionError(
+            container_id,
+            "container",
+            properties_str,
+            message,
+            row_numbers,
+            "rows",
+        )
+
+    @staticmethod
+    def _validate_container_indices_same_order(
+        index_properties: list[_ContainerPropertyIndex], row_numbers: tuple[int, ...], container_id: dm.ContainerId
+    ) -> list[PropertyInvalidDefinitionError]:
+        """Checks whether there are multiple properties with the same order in a composite index."""
+        properties_by_order: dict[int, list[tuple[int, PhysicalProperty]]] = defaultdict(list)
+        for index_prop in index_properties:
+            if index_prop.index.order is not None:
+                properties_by_order[index_prop.index.order].append((index_prop.location, index_prop.property_))
+        same_order_errors: list[PropertyInvalidDefinitionError] = []
+        for order, props in properties_by_order.items():
+            if len(props) > 1:
+                properties_str = humanize_collection([prop.view_property for _, prop in props])
+                message = (
+                    "You cannot have multiple properties with the same order in a composite index. "
+                    f"Got order={order} for all composite properties."
+                    "Please ensure that each property has an unique order."
+                )
+                same_order_errors.append(
+                    PropertyInvalidDefinitionError(
+                        container_id,
+                        "container",
+                        properties_str,
+                        message,
+                        row_numbers,
+                        "rows",
+                    )
+                )
+        return same_order_errors
+
     @staticmethod
     def _containers_are_proper_size(dms_schema: DMSSchema) -> IssueList:
         errors = IssueList()

{cognite_neat-0.123.8 → cognite_neat-0.123.10}/cognite/neat/core/_data_model/models/physical/_verified.py

@@ -32,6 +32,7 @@ from cognite.neat.core._data_model.models._types import (
 from cognite.neat.core._data_model.models.data_types import DataType
 from cognite.neat.core._data_model.models.entities import (
     ConceptualEntity,
+    ContainerIndexEntity,
     DMSNodeEntity,
     EdgeEntity,
     HasDataFilter,
@@ -40,12 +41,13 @@ from cognite.neat.core._data_model.models.entities import (
     PhysicalUnknownEntity,
     RawFilter,
     ReverseConnectionEntity,
+    Undefined,
     ViewEntity,
     ViewEntityList,
 )
 from cognite.neat.core._data_model.models.entities._types import ContainerEntityList, ContainerIndexListType
 from cognite.neat.core._issues.errors import NeatValueError
-from cognite.neat.core._issues.warnings._general import NeatValueWarning
+from cognite.neat.core._issues.warnings import NeatValueWarning, PropertyDefinitionWarning
 
 if TYPE_CHECKING:
     from cognite.neat.core._data_model.models import ConceptualDataModel
@@ -257,6 +259,53 @@ class PhysicalProperty(SheetRow):
             )
         return value
 
+    @field_validator("index", mode="after")
+    @classmethod
+    def index_set_correctly(cls, value: list[ContainerIndexEntity] | None, info: ValidationInfo) -> Any:
+        if value is None:
+            return value
+        try:
+            container = str(info.data["container"])
+            container_property = str(info.data["container_property"])
+        except KeyError:
+            raise ValueError("Container and container property must be set to use indexes") from None
+        max_count = info.data.get("max_count")
+        is_list = (
+            max_count is not None and (isinstance(max_count, int | float) and max_count > 1)
+        ) or max_count is float("inf")
+        for index in value:
+            if index.prefix is Undefined:
+                message = f"The type of index is not defined. Please set 'inverted:{index!s}' or 'btree:{index!s}'."
+                warnings.warn(
+                    PropertyDefinitionWarning(container, "container property", container_property, message),
+                    stacklevel=2,
+                )
+            elif index.prefix == "inverted" and not is_list:
+                message = (
+                    "It is not recommended to use inverted index on non-list properties. "
+                    "Please consider using btree index instead."
+                )
+                warnings.warn(
+                    PropertyDefinitionWarning(container, "container property", container_property, message),
+                    stacklevel=2,
+                )
+            elif index.prefix == "btree" and is_list:
+                message = (
+                    "It is not recommended to use btree index on list properties. "
+                    "Please consider using inverted index instead."
+                )
+                warnings.warn(
+                    PropertyDefinitionWarning(container, "container property", container_property, message),
+                    stacklevel=2,
+                )
+            if index.prefix == "inverted" and (index.cursorable is not None or index.by_space is not None):
+                message = "Cursorable and bySpace are not supported for inverted indexes. These will be ignored."
+                warnings.warn(
+                    PropertyDefinitionWarning(container, "container property", container_property, message),
+                    stacklevel=2,
+                )
+        return value
+
     @field_serializer("value_type", when_used="always")
     def as_dms_type(self, value_type: DataType | EdgeEntity | ViewEntity, info: SerializationInfo) -> str:
         if isinstance(value_type, DataType):

{cognite_neat-0.123.8 → cognite_neat-0.123.10}/cognite/neat/core/_issues/_base.py

@@ -124,7 +124,7 @@ class NeatIssue:
         if isinstance(value, str | int | bool | float):
             return value
         elif isinstance(value, frozenset):
-            return [cls._dump_value(item) for item in value]
+            return [cls._dump_value(item) for item in sorted(value)]
         elif isinstance(value, Path):
             return value.as_posix()
         elif isinstance(value, tuple):

{cognite_neat-0.123.8 → cognite_neat-0.123.10}/cognite/neat/core/_issues/errors/__init__.py

@@ -16,6 +16,7 @@ from ._general import NeatImportError, NeatTypeError, NeatValueError, RegexViola
 from ._properties import (
     PropertyDefinitionDuplicatedError,
     PropertyDefinitionError,
+    PropertyInvalidDefinitionError,
     PropertyMappingDuplicatedError,
     PropertyNotFoundError,
     PropertyTypeNotSupportedError,
@@ -65,6 +66,7 @@ __all__ = [
     "OxigraphStorageLockedError",
     "PropertyDefinitionDuplicatedError",
     "PropertyDefinitionError",
+    "PropertyInvalidDefinitionError",
     "PropertyMappingDuplicatedError",
     "PropertyNotFoundError",
     "PropertyTypeNotSupportedError",

{cognite_neat-0.123.8 → cognite_neat-0.123.10}/cognite/neat/core/_issues/errors/_properties.py

@@ -60,6 +60,17 @@ class PropertyDefinitionDuplicatedError(PropertyError[T_Identifier]):
     location_name: str | None = None
 
 
+@dataclass(unsafe_hash=True)
+class PropertyInvalidDefinitionError(PropertyError[T_Identifier]):
+    """The {resource_type} with identifier {identifier} has an invalid definition of {property_name}. {reason}"""
+
+    extra = "in locations {locations} with name {location_name}"
+
+    reason: str
+    locations: tuple[str | int, ...] | None = None
+    location_name: str | None = None
+
+
 @dataclass(unsafe_hash=True)
 class PropertyMappingDuplicatedError(PropertyError[T_Identifier], Generic[T_Identifier, T_ReferenceIdentifier]):
     """The {resource_type} with identifier {identifier}.{property_name} is mapped to by: {mappings}. Ensure

{cognite_neat-0.123.8 → cognite_neat-0.123.10}/cognite/neat/core/_issues/warnings/__init__.py

@@ -34,6 +34,7 @@ from ._models import (
 from ._properties import (
     PropertyDataTypeConversionWarning,
     PropertyDefinitionDuplicatedWarning,
+    PropertyDefinitionWarning,
     PropertyDirectRelationLimitWarning,
     PropertyMultipleValueWarning,
     PropertyNotFoundWarning,
@@ -72,6 +73,7 @@ __all__ = [
     "PrincipleSolutionBuildsOnEnterpriseWarning",
     "PropertyDataTypeConversionWarning",
     "PropertyDefinitionDuplicatedWarning",
+    "PropertyDefinitionWarning",
     "PropertyDirectRelationLimitWarning",
     "PropertyMultipleValueWarning",
     "PropertyNotFoundWarning",

{cognite_neat-0.123.8 → cognite_neat-0.123.10}/cognite/neat/core/_issues/warnings/_properties.py

@@ -90,6 +90,17 @@ class PropertyMultipleValueWarning(PropertyWarning[T_Identifier]):
     value: str
 
 
+@dataclass(unsafe_hash=True)
+class PropertyDefinitionWarning(PropertyWarning[T_Identifier]):
+    """The {resource_type} with identifier {identifier} property {property_name}: {reason}"""
+
+    extra = "in locations {locations} with name {location_name}"
+
+    reason: str
+    locations: tuple[str | int, ...] | None = None
+    location_name: str | None = None
+
+
 @dataclass(unsafe_hash=True)
 class ReversedConnectionNotFeasibleWarning(PropertyWarning[T_Identifier]):
     """The {resource_type} {identifier}.{property_name} cannot be created: {reason}"""

cognite_neat-0.123.10/last_changelog_entry.md

@@ -0,0 +1,3 @@
+### Improved
+
+- Regex on property id has been relaxed accepting web safe characters

cognite_neat-0.123.10/last_git_message.txt

@@ -0,0 +1,21 @@
+Conceptual data model relaxation on property id (#1245)
+
+# Description
+
+This is continued relaxation of regex for conceptual data model to
+support various source data models import to NEAT
+
+## Bump
+
+- [x] Patch
+- [ ] Minor
+- [ ] Skip
+
+## Changelog
+### Improved
+
+- Regex on property id has been relaxed accepting web safe characters
+
+---------
+
+Co-authored-by: Nikola Vasiljevic <nikola@Nikolas-MacBook-Air.local>

cognite_neat-0.123.10/last_version.txt

@@ -0,0 +1 @@
+0.123.9

{cognite_neat-0.123.8 → cognite_neat-0.123.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cognite-neat"
-version = "0.123.8"
+version = "0.123.10"
 readme = "README.md"
 description = "Knowledge graph transformation"
 authors = [

cognite_neat-0.123.10/tests/data/_schema/physical_yamls/invalid_indices.expected_issues.yaml

@@ -0,0 +1,77 @@
+- NeatIssue: PropertyDefinitionDuplicatedError
+  identifier:
+    externalId: MyDescribable
+    space: my_space
+    type: container
+  locationName: rows
+  locations:
+  - 3
+  - 6
+  propertyName: name
+  propertyValues:
+  - btree:NameIndex(cursorable=True)
+  - inverted:NameIndex
+  resourceType: container
+- NeatIssue: PropertyDefinitionWarning
+  identifier: my_space:MyDescribable
+  propertyName: areaCode
+  reason: The type of index is not defined. Please set 'inverted:AreaCodeIndex' or
+    'btree:AreaCodeIndex'.
+  resourceType: container property
+- NeatIssue: PropertyDefinitionWarning
+  identifier: my_space:MyDescribable
+  propertyName: location
+  reason: It is not recommended to use inverted index on non-list properties. Please
+    consider using btree index instead.
+  resourceType: container property
+- NeatIssue: PropertyDefinitionWarning
+  identifier: my_space:MyDescribable
+  propertyName: name
+  reason: It is not recommended to use inverted index on non-list properties. Please
+    consider using btree index instead.
+  resourceType: container property
+- NeatIssue: PropertyDefinitionWarning
+  identifier: my_space:MyDescribable
+  propertyName: relatedTerms
+  reason: Cursorable and bySpace are not supported for inverted indexes. These will
+    be ignored.
+  resourceType: container property
+- NeatIssue: PropertyDefinitionWarning
+  identifier: my_space:MyDescribable
+  propertyName: relatedTerms
+  reason: It is not recommended to use inverted index on non-list properties. Please
+    consider using btree index instead.
+  resourceType: container property
+- NeatIssue: PropertyDefinitionWarning
+  identifier: my_space:MyDescribable
+  propertyName: tags
+  reason: It is not recommended to use inverted index on non-list properties. Please
+    consider using btree index instead.
+  resourceType: container property
+- NeatIssue: PropertyInvalidDefinitionError
+  identifier:
+    externalId: MyDescribable
+    space: my_space
+    type: container
+  locationName: rows
+  locations:
+  - 1
+  - 2
+  propertyName: code and department
+  reason: You must specify the order when using a composite index. For example btree:codeDepartmentIndex(order=1)
+    and btree:codeDepartmentIndex(order=2).
+  resourceType: container
+- NeatIssue: PropertyInvalidDefinitionError
+  identifier:
+    externalId: MyDescribable
+    space: my_space
+    type: container
+  locationName: rows
+  locations:
+  - 7
+  - 8
+  propertyName: location and tags
+  reason: You cannot have multiple properties with the same order in a composite index.
+    Got order=42 for all composite properties.Please ensure that each property has
+    an unique order.
+  resourceType: container

cognite_neat-0.123.10/tests/data/_schema/physical_yamls/invalid_indices.yaml

@@ -0,0 +1,92 @@
+containers:
+- container: MyDescribable
+metadata:
+  created: '2025-05-27T06:35:07.129608'
+  creator: doctrino
+  external_id: invalidIndices
+  role: DMS Architect
+  space: my_space
+  updated: '2025-05-27T06:35:07.129608'
+  version: v1
+properties:
+- container: MyDescribable
+  container_property: nonIndexedProperty
+  value_type: text
+  view: FirstView
+  view_property: nonIndexedProperty
+- container: MyDescribable
+  container_property: code
+  # Composite index without order
+  index: btree:codeDepartmentIndex
+  value_type: text
+  view: FirstView
+  view_property: code
+- container: MyDescribable
+  container_property: department
+  # Composite index without order
+  index: btree:codeDepartmentIndex
+  value_type: text
+  view: FirstView
+  view_property: department
+- container: MyDescribable
+  container_property: name
+    # This property is defined twice with different indices, which is invalid.
+  index: btree:NameIndex(cursorable=True)
+  value_type: text
+  view: FirstView
+  view_property: name
+- container: MyDescribable
+  container_property: anotherNonIndexedProperty
+  value_type: text
+  view: FirstView
+  view_property: anotherNonIndexedProperty
+- container: MyDescribable
+  container_property: areaCode
+  # Index type not defined.container_property:
+  index: AreaCodeIndex
+  value_type: text
+  view: FirstView
+  view_property: areaCode
+- container: MyDescribable
+  container_property: name
+  # - Redefinition of index on the same property
+  # - Inverted index on a property that should be btree
+  index: inverted:NameIndex
+  value_type: text
+  view: SecondView
+  view_property: name
+- container: MyDescribable
+  container_property: location
+  index: inverted:locationTagsIndex(order=42)
+  value_type: text
+  view: SecondView
+  view_property: location
+- container: MyDescribable
+  container_property: tags
+  # Ambiguous order, location and tags have the same order
+  index: inverted:locationTagsIndex(order=42)
+  max_value: 1000
+  value_type: text
+  view: SecondView
+  view_property: tags
+- container: MyDescribable
+  container_property: alias
+  # Wrong index type, should be inverted
+  index: btree:AliasIndex(cursorable=True)
+  max_value: 1000
+  value_type: text
+  view: SecondView
+  view_property: alias
+- container: MyDescribable
+  container_property: relatedTerms
+  # Cursorable is not valid for inverted indices
+  index: inverted:RelatedTermsIndex(cursorable=True)
+  max_value: 1000
+  value_type: text
+  view: SecondView
+  view_property: relatedTerms
+views:
+- in_model: true
+  view: FirstView
+- in_model: true
+  view: SecondView