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

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

@@ -3,23 +3,25 @@ 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
 from cognite.client.data_classes.data_modeling import ContainerId, ViewId
 from rdflib import Namespace, URIRef
 
-from cognite.neat.core._constants import (
+from cognite.neat.v0.core._constants import (
     DEFAULT_NAMESPACE,
     DMS_DIRECT_RELATION_LIST_DEFAULT_LIMIT,
 )
-from cognite.neat.core._data_model.models._base_unverified import (
+from cognite.neat.v0.core._data_model._constants import SPLIT_ON_COMMA_PATTERN
+from cognite.neat.v0.core._data_model.models._base_unverified import (
     UnverifiedComponent,
     UnverifiedDataModel,
 )
-from cognite.neat.core._data_model.models.data_types import DataType
-from cognite.neat.core._data_model.models.entities import (
+from cognite.neat.v0.core._data_model.models.data_types import DataType
+from cognite.neat.v0.core._data_model.models.entities import (
+    ContainerConstraintEntity,
     ContainerEntity,
     ContainerIndexEntity,
     DMSNodeEntity,
@@ -30,9 +32,9 @@ from cognite.neat.core._data_model.models.entities import (
     load_connection,
     load_dms_value_type,
 )
-from cognite.neat.core._data_model.models.entities._wrapped import DMSFilter
-from cognite.neat.core._issues.warnings import DeprecatedWarning
-from cognite.neat.core._utils.rdf_ import uri_display_name
+from cognite.neat.v0.core._data_model.models.entities._wrapped import DMSFilter
+from cognite.neat.v0.core._issues.warnings import DeprecatedWarning
+from cognite.neat.v0.core._utils.rdf_ import uri_display_name
 
 from ._verified import (
     _DEFAULT_VERSION,
@@ -137,7 +139,7 @@ class UnverifiedPhysicalProperty(UnverifiedComponent[PhysicalProperty]):
     container: str | None = None
     container_property: str | None = None
     index: str | list[str | ContainerIndexEntity] | ContainerIndexEntity | None = None
-    constraint: str | list[str] | None = None
+    constraint: str | list[str] | list[ContainerConstraintEntity] | ContainerConstraintEntity | None = None
     neatId: str | URIRef | None = None
     conceptual: str | URIRef | None = None
 
@@ -160,34 +162,44 @@ 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)]
-        elif isinstance(self.index, str) and "," in self.index:
+            output["Index"] = [ContainerIndexEntity.load(self.index, return_on_failure=True)]
+        elif isinstance(self.index, str):
             output["Index"] = [
-                ContainerIndexEntity.load(index.strip()) for index in self.index.split(",") if index.strip()
+                ContainerIndexEntity.load(index.strip(), return_on_failure=True)
+                for index in SPLIT_ON_COMMA_PATTERN.split(self.index)
+                if index.strip()
             ]
         elif isinstance(self.index, list):
             index_list: list[ContainerIndexEntity | PhysicalUnknownEntity] = []
             for index in self.index:
                 if isinstance(index, ContainerIndexEntity):
                     index_list.append(index)
-                elif isinstance(index, str) and "," in index:
+                elif isinstance(index, str):
                     index_list.extend(
-                        [ContainerIndexEntity.load(idx.strip()) for idx in index.split(",") if 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
+
+            output["Constraint"] = _parse_constraints(self.constraint, default_space)
         return output
 
     def referenced_view(self, default_space: str, default_version: str) -> ViewEntity:
@@ -240,7 +252,7 @@ class UnverifiedPhysicalContainer(UnverifiedComponent[PhysicalContainer]):
     container: str
     name: str | None = None
     description: str | None = None
-    constraint: str | None = None
+    constraint: str | list[str] | list[ContainerConstraintEntity] | ContainerConstraintEntity | None = None
     neatId: str | URIRef | None = None
     used_for: Literal["node", "edge", "all"] | None = None
 
@@ -250,23 +262,33 @@ 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["Constraint"] = (
-            [ContainerEntity.load(constraint.strip(), space=default_space) for constraint in self.constraint.split(",")]
-            if self.constraint
-            else None
-        )
+        output["Container"] = self.as_entity_id(default_space, return_on_failure=True)
+        output["Constraint"] = _parse_constraints(self.constraint, default_space)
         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":
         constraints: list[str] = []
-        for _, constraint_obj in (container.constraints or {}).items():
+        for constraint_name, constraint_obj in (container.constraints or {}).items():
             if isinstance(constraint_obj, dm.RequiresConstraint):
-                constraints.append(str(ContainerEntity.from_id(constraint_obj.require)))
+                constraint = ContainerConstraintEntity(
+                    prefix="requires", suffix=constraint_name, require=ContainerEntity.from_id(constraint_obj.require)
+                )
+                constraints.append(str(constraint))
+
             # UniquenessConstraint it handled in the properties
         container_entity = ContainerEntity.from_id(container.as_id())
         return cls(
@@ -299,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
@@ -354,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
 
 
@@ -452,3 +506,52 @@ class UnverifiedPhysicalDataModel(UnverifiedDataModel[PhysicalDataModel]):
     def imported_views_and_containers_ids(self) -> tuple[set[ViewId], set[ContainerId]]:
         views, containers = self.imported_views_and_containers()
         return {view.as_id() for view in views}, {container.as_id() for container in containers}
+
+
+def _parse_constraints(
+    constraint: str | list[str] | list[ContainerConstraintEntity] | ContainerConstraintEntity | None,
+    default_space: str | None = None,
+) -> list[ContainerConstraintEntity | PhysicalUnknownEntity] | None:
+    """Parse constraint input into a standardized list of ContainerConstraintEntity objects.
+
+    Args:
+        constraint: The constraint input in various formats
+        default_space: Default space to use when loading constraint entities
+
+    Returns:
+        List of parsed constraint entities, or None if no constraints
+    """
+    if constraint is None:
+        return None
+
+    if isinstance(constraint, ContainerConstraintEntity):
+        return [constraint]
+
+    if isinstance(constraint, str) and "," not in constraint:
+        return [ContainerConstraintEntity.load(constraint, return_on_failure=True, space=default_space)]
+
+    if isinstance(constraint, str):
+        return [
+            ContainerConstraintEntity.load(constraint_item.strip(), return_on_failure=True, space=default_space)
+            for constraint_item in SPLIT_ON_COMMA_PATTERN.split(constraint)
+            if constraint_item.strip()
+        ]
+
+    if isinstance(constraint, list):
+        constraint_list: list[ContainerConstraintEntity | PhysicalUnknownEntity] = []
+        for constraint_item in constraint:
+            if isinstance(constraint_item, ContainerConstraintEntity):
+                constraint_list.append(constraint_item)
+            elif isinstance(constraint_item, str):
+                constraint_list.extend(
+                    [
+                        ContainerConstraintEntity.load(idx.strip(), return_on_failure=True, space=default_space)
+                        for idx in SPLIT_ON_COMMA_PATTERN.split(constraint_item)
+                        if idx.strip()
+                    ]
+                )
+            else:
+                raise TypeError(f"Unexpected type for constraint: {type(constraint_item)}")
+        return constraint_list
+
+    raise TypeError(f"Unexpected type for constraint: {type(constraint)}")

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

@@ -1,7 +1,9 @@
 import warnings
 from collections import Counter, defaultdict
 from collections.abc import Mapping
+from dataclasses import dataclass
 from functools import lru_cache
+from typing import cast
 
 from cognite.client import data_modeling as dm
 from cognite.client.data_classes.data_modeling import ContainerList, ViewId, ViewList
@@ -12,49 +14,68 @@ from cognite.client.data_classes.data_modeling.views import (
     ViewPropertyApply,
 )
 
-from cognite.neat.core._client import NeatClient
-from cognite.neat.core._client.data_classes.data_modeling import ViewApplyDict
-from cognite.neat.core._client.data_classes.schema import DMSSchema
-from cognite.neat.core._constants import (
+from cognite.neat.v0.core._client import NeatClient
+from cognite.neat.v0.core._client.data_classes.data_modeling import ViewApplyDict
+from cognite.neat.v0.core._client.data_classes.schema import DMSSchema
+from cognite.neat.v0.core._constants import (
     COGNITE_MODELS,
     COGNITE_SPACES,
     DMS_CONTAINER_PROPERTY_SIZE_LIMIT,
     DMS_VIEW_CONTAINER_SIZE_LIMIT,
+    get_base_concepts,
 )
-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 (
+from cognite.neat.v0.core._data_model.models._import_contexts import ImportContext, SpreadsheetContext
+from cognite.neat.v0.core._data_model.models.data_types import DataType
+from cognite.neat.v0.core._data_model.models.entities import ContainerEntity, RawFilter
+from cognite.neat.v0.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 (
+from cognite.neat.v0.core._issues import IssueList, NeatError
+from cognite.neat.v0.core._issues.errors import (
     CDFMissingClientError,
     PropertyDefinitionDuplicatedError,
+    PropertyInvalidDefinitionError,
     PropertyMappingDuplicatedError,
     PropertyNotFoundError,
     ResourceDuplicatedError,
     ResourceNotFoundError,
     ReversedConnectionNotFeasibleError,
 )
-from cognite.neat.core._issues.errors._external import CDFMissingResourcesError
-from cognite.neat.core._issues.warnings import (
+from cognite.neat.v0.core._issues.errors._external import CDFMissingResourcesError
+from cognite.neat.v0.core._issues.warnings import (
     NotSupportedHasDataFilterLimitWarning,
     NotSupportedViewContainerLimitWarning,
     ReversedConnectionNotFeasibleWarning,
     UndefinedViewWarning,
     user_modeling,
 )
-from cognite.neat.core._issues.warnings.user_modeling import (
+from cognite.neat.v0.core._issues.warnings._models import ViewWithoutPropertiesWarning
+from cognite.neat.v0.core._issues.warnings.user_modeling import (
     ContainerPropertyLimitWarning,
     DirectRelationMissingSourceWarning,
     NotNeatSupportedFilterWarning,
 )
-from cognite.neat.core._utils.spreadsheet import SpreadsheetRead
-from cognite.neat.core._utils.text import humanize_collection
+from cognite.neat.v0.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."""
@@ -63,15 +84,23 @@ class PhysicalValidation:
         self,
         data_model: PhysicalDataModel,
         client: NeatClient | None = None,
-        read_info_by_spreadsheet: dict[str, SpreadsheetRead] | None = None,
+        context: ImportContext | None = None,
     ) -> None:
+        # import here to avoid circular import issues
+        from cognite.neat.v0.core._data_model.analysis._base import DataModelAnalysis
+
         self._data_model = data_model
         self._client = client
         self._metadata = data_model.metadata
         self._properties = data_model.properties
         self._containers = data_model.containers
         self._views = data_model.views
-        self._read_info_by_spreadsheet = read_info_by_spreadsheet or {}
+        self._read_info_by_spreadsheet = context if isinstance(context, SpreadsheetContext) else SpreadsheetContext()
+
+        self.analysis = DataModelAnalysis(physical=self._data_model)
+        self._cdf_concepts = {
+            ViewEntity.load(concept_as_string) for concept_as_string in get_base_concepts(base_model="CogniteCore")
+        }
 
     def imported_views_and_containers_ids(
         self, include_views_with_no_properties: bool = True
@@ -93,9 +122,9 @@ class PhysicalValidation:
             view_with_properties.add(prop.view)
 
         for container in self._containers or []:
-            for required in container.constraint or []:
-                if required not in existing_containers:
-                    imported_containers.add(required)
+            for constraint in container.constraint or []:
+                if constraint.require not in existing_containers:
+                    imported_containers.add(cast(ContainerEntity, constraint.require))
 
         if include_views_with_no_properties:
             extra_views = existing_views - view_with_properties
@@ -145,16 +174,21 @@ 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()
 
         # Validated for duplicated resource
         issue_list.extend(self._duplicated_resources())
 
+        # Validate if views are defined (i.e. have at least one property defined, or inherited)
+        issue_list.extend(self._views_without_properties_exist())
+
         # 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)
@@ -172,6 +206,23 @@ class PhysicalValidation:
         issue_list.extend(self._same_space_views_and_data_model())
         return issue_list
 
+    def _views_without_properties_exist(self) -> IssueList:
+        """Check if there are views that do not have any properties defined directly or inherited."""
+        issue_list = IssueList()
+        views = {view.view for view in self._views}
+        ancestors_by_view = self.analysis.implements_by_view(include_ancestors=True, include_different_space=True)
+        views_with_properties = self.analysis.defined_views().union(self._cdf_concepts)
+
+        if candidate_views := views.difference(views_with_properties):
+            for view in candidate_views:
+                # Here we check if at least one of the ancestors of the view has properties
+                if (ancestors := ancestors_by_view.get(view)) and ancestors.intersection(views_with_properties):
+                    continue
+
+                issue_list.append_if_not_exist(ViewWithoutPropertiesWarning(view_id=view.as_id()))
+
+        return issue_list
+
     def _same_space_views_and_data_model(self) -> IssueList:
         issue_list = IssueList()
 
@@ -320,13 +371,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 +457,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,
@@ -406,8 +471,11 @@ class PhysicalValidation:
                     )
                 )
             constraint_definitions = {
-                ",".join(prop.constraint) for _, prop in properties if prop.constraint is not None
+                ",".join([str(constraint) for constraint in prop.constraint])
+                for _, prop in properties
+                if prop.constraint is not None
             }
+
             if len(constraint_definitions) > 1:
                 errors.append(
                     PropertyDefinitionDuplicatedError[dm.ContainerId](
@@ -422,6 +490,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()