cognite-neat 0.124.0__py3-none-any.whl → 0.125.1__py3-none-any.whl

cognite/neat/_data_model/importers/__init__.py

@@ -1,3 +1,4 @@
 from ._base import DMSImporter
+from ._table_importer.importer import DMSTableImporter
 
-__all__ = ["DMSImporter"]
+__all__ = ["DMSImporter", "DMSTableImporter"]

cognite/neat/_data_model/importers/_table_importer/data_classes.py

@@ -0,0 +1,141 @@
+from collections.abc import Mapping
+from typing import Annotated, cast
+
+from pydantic import AliasGenerator, BaseModel, BeforeValidator, Field, model_validator
+from pydantic.alias_generators import to_camel
+
+from cognite.neat._data_model.models.entities import ParsedEntity, parse_entities, parse_entity
+from cognite.neat._utils.text import title_case
+from cognite.neat._utils.useful_types import CellValueType
+
+
+def parse_entity_str(v: str) -> ParsedEntity:
+    try:
+        return parse_entity(v)
+    except ValueError as e:
+        raise ValueError(f"Invalid entity syntax: {e}") from e
+
+
+def parse_entities_str(v: str) -> list[ParsedEntity] | None:
+    try:
+        return parse_entities(v)
+    except ValueError as e:
+        raise ValueError(f"Invalid entity list syntax: {e}") from e
+
+
+Entity = Annotated[ParsedEntity, BeforeValidator(parse_entity_str, str)]
+EntityList = Annotated[list[ParsedEntity], BeforeValidator(parse_entities_str, str)]
+
+
+class TableObj(
+    BaseModel,
+    extra="ignore",
+    alias_generator=AliasGenerator(
+        validation_alias=title_case,
+        serialization_alias=to_camel,
+    ),
+): ...
+
+
+class MetadataValue(TableObj):
+    key: str
+    value: CellValueType
+
+
+class DMSProperty(TableObj):
+    view: Entity
+    view_property: str
+    name: str | None = None
+    description: str | None = None
+    connection: Entity | None
+    value_type: Entity
+    min_count: int | None
+    max_count: int | None
+    immutable: bool | None = None
+    default: CellValueType | None = None
+    auto_increment: bool | None = None
+    container: Entity | None = None
+    container_property: str | None = None
+    container_property_name: str | None = None
+    container_property_description: str | None = None
+    index: EntityList | None = None
+    constraint: EntityList | None = None
+
+
+class DMSView(TableObj):
+    view: Entity
+    name: str | None = None
+    description: str | None = None
+    implements: EntityList | None = None
+    filter: str | None = None
+    in_model: bool | None = None
+
+
+class DMSContainer(TableObj):
+    container: Entity
+    name: str | None = None
+    description: str | None = None
+    constraint: EntityList | None = None
+    used_for: str | None = None
+
+
+class DMSEnum(TableObj):
+    collection: str
+    value: str
+    name: str | None = None
+    description: str | None = None
+
+
+class DMSNode(TableObj):
+    node: Entity
+
+
+class TableDMS(TableObj):
+    metadata: list[MetadataValue]
+    properties: list[DMSProperty]
+    views: list[DMSView]
+    containers: list[DMSContainer] = Field(default_factory=list)
+    enum: list[DMSEnum] = Field(default_factory=list)
+    nodes: list[DMSNode] = Field(default_factory=list)
+
+    @model_validator(mode="before")
+    def _title_case_keys(
+        cls, data: dict[str, list[dict[str, CellValueType]]]
+    ) -> dict[str, list[dict[str, CellValueType]]]:
+        if isinstance(data, dict):
+            # We are case-insensitive on the table names.
+            return {title_case(k): v for k, v in data.items()}
+        return data
+
+
+DMS_API_MAPPING: Mapping[str, Mapping[str, str]] = {
+    "Views": {
+        "space": "View",
+        "externalId": "View",
+        "version": "View",
+        **{
+            cast(str, field_.serialization_alias): cast(str, field_.validation_alias)
+            for field_id, field_ in DMSView.model_fields.items()
+            if field_id != "View"
+        },
+    },
+    "Containers": {
+        "space": "Container",
+        "externalId": "Container",
+        **{
+            cast(str, field_.serialization_alias): cast(str, field_.validation_alias)
+            for field_id, field_ in DMSContainer.model_fields.items()
+            if field_id != "Container"
+        },
+    },
+    "Properties": {
+        "space": "View",
+        "externalId": "View",
+        "property": "ViewProperty",
+        **{
+            cast(str, field_.serialization_alias): cast(str, field_.validation_alias)
+            for field_id, field_ in DMSProperty.model_fields.items()
+            if field_id not in ("View", "ViewProperty")
+        },
+    },
+}

cognite/neat/_data_model/importers/_table_importer/importer.py

@@ -0,0 +1,76 @@
+from collections.abc import Mapping
+from typing import ClassVar, cast
+
+from pydantic import ValidationError
+
+from cognite.neat._data_model.importers._base import DMSImporter
+from cognite.neat._data_model.models.dms import (
+    RequestSchema,
+)
+from cognite.neat._exceptions import DataModelImportError
+from cognite.neat._issues import ModelSyntaxError
+from cognite.neat._utils.useful_types import CellValueType
+from cognite.neat._utils.validation import as_json_path, humanize_validation_error
+
+from .data_classes import TableDMS
+
+
+class DMSTableImporter(DMSImporter):
+    """Imports DMS from a table structure.
+
+    The tables can are expected to be a dictionary where the keys are the table names and the values
+    are lists of dictionaries representing the rows in the table.
+    """
+
+    # We can safely cast as we know the validation_alias is always set to a str.
+    REQUIRED_SHEETS = tuple(
+        cast(str, field_.validation_alias) for field_ in TableDMS.model_fields.values() if field_.is_required()
+    )
+    REQUIRED_SHEET_MESSAGES: ClassVar[Mapping[str, str]] = {
+        f"Missing required column: {sheet!r}": f"Missing required sheet: {sheet!r}" for sheet in REQUIRED_SHEETS
+    }
+
+    def __init__(self, tables: dict[str, list[dict[str, CellValueType]]]) -> None:
+        self._table = tables
+
+    def to_data_model(self) -> RequestSchema:
+        raise NotImplementedError()
+
+    def _read_tables(self) -> TableDMS:
+        try:
+            # Check tables, columns, data type and entity syntax.
+            table = TableDMS.model_validate(self._table)
+        except ValidationError as e:
+            errors = self._create_error_messages(e)
+            raise DataModelImportError(errors) from None
+        return table
+
+    def _create_error_messages(self, error: ValidationError) -> list[ModelSyntaxError]:
+        errors: list[ModelSyntaxError] = []
+        seen: set[str] = set()
+        for message in humanize_validation_error(
+            error,
+            humanize_location=self._location,
+            field_name="column",
+            missing_required_descriptor="missing",
+        ):
+            # Replace messages about missing required columns with missing required sheets.
+            message = self.REQUIRED_SHEET_MESSAGES.get(message, message)
+            if message in seen:
+                # We treat all rows as the same, so we get duplicated errors for each row.
+                continue
+            seen.add(message)
+            errors.append(ModelSyntaxError(message=message))
+        return errors
+
+    @staticmethod
+    def _location(loc: tuple[str | int, ...]) -> str:
+        if isinstance(loc[0], str) and len(loc) == 2:  # Sheet + row.
+            # We skip the row as we treat all rows as the same. For example, if a required column is missing in one
+            # row, it is missing in all rows.
+            return f"{loc[0]} sheet"
+        elif len(loc) == 3 and isinstance(loc[0], str) and isinstance(loc[1], int) and isinstance(loc[2], str):
+            # This means there is something wrong in a specific cell.
+            return f"{loc[0]} sheet row {loc[1] + 1} column {loc[2]!r}"
+        # This should be unreachable as the TableDMS model only has 2 levels.
+        return as_json_path(loc)

cognite/neat/_data_model/importers/_table_importer/source.py

@@ -0,0 +1,89 @@
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+
+from .data_classes import DMS_API_MAPPING
+
+
+@dataclass
+class SpreadsheetReadContext:
+    """This class is used to store information about the source spreadsheet.
+
+    It is used to adjust row numbers to account for header rows and empty rows
+    such that the error/warning messages are accurate.
+    """
+
+    header_row: int = 1
+    empty_rows: list[int] = field(default_factory=list)
+    skipped_rows: list[int] = field(default_factory=list)
+    is_one_indexed: bool = True
+
+    def __post_init__(self) -> None:
+        self.empty_rows.sort()
+        self.skipped_rows.sort()
+
+    def adjusted_row_number(self, row_no: int) -> int:
+        output = row_no
+        for empty_row in self.empty_rows:
+            if empty_row <= output:
+                output += 1
+            else:
+                break
+
+        for skipped_rows in self.skipped_rows:
+            if skipped_rows <= output:
+                output += 1
+            else:
+                break
+
+        return output + self.header_row + (1 if self.is_one_indexed else 0)
+
+
+@dataclass
+class TableSource:
+    source: str
+    table_read: dict[str, SpreadsheetReadContext] = field(default_factory=dict)
+
+    def location(self, path: tuple[int | str, ...]) -> str:
+        table_id: str | None = None
+        row_no: int | None = None
+        column: str | None = None
+        if len(path) >= 1 and isinstance(path[0], str):
+            table_id = path[0]
+        if len(path) >= 2 and isinstance(path[1], int):
+            row_no = path[1]
+        if len(path) >= 3 and isinstance(path[2], str):
+            column = path[2]
+            column = self.field_to_column(table_id, column)
+        if isinstance(row_no, int):
+            row_no = self.adjust_row_number(table_id, row_no)
+        location_parts = []
+        if table_id is not None:
+            location_parts.append(f"table {table_id!r}")
+        if row_no is not None:
+            location_parts.append(f"row {row_no}")
+        if column is not None:
+            location_parts.append(f"column {column!r}")
+        if len(path) > 4:
+            location_parts.append("-> " + ".".join(str(p) for p in path[3:]))
+
+        return " ".join(location_parts)
+
+    def adjust_row_number(self, table_id: str | None, row_no: int) -> int:
+        table_read = table_id and self.table_read.get(table_id)
+        if table_read:
+            return table_read.adjusted_row_number(row_no)
+        return row_no + 1  # Convert to 1-indexed if no table read info is available
+
+    @classmethod
+    def field_to_column(cls, table_id: str | None, field_: str) -> str:
+        """Maps the field name used in the DMS API to the column named used by Neat."""
+        mapping = cls.field_mapping(table_id)
+        if mapping is not None:
+            return mapping.get(field_, field_)
+        return field_
+
+    @classmethod
+    def field_mapping(cls, table_id: str | int | None) -> Mapping[str, str] | None:
+        if not isinstance(table_id, str):
+            return None
+        return DMS_API_MAPPING.get(table_id)

cognite/neat/_exceptions.py

@@ -0,0 +1,17 @@
+from ._issues import ModelSyntaxError
+
+
+class NeatException(Exception):
+    """Base class for all exceptions raised by Neat."""
+
+    pass
+
+
+class DataModelImportError(NeatException):
+    """Raised when there is an error importing a model."""
+
+    def __init__(self, errors: list[ModelSyntaxError]) -> None:
+        self.errors = errors
+
+    def __str__(self) -> str:
+        return f"Model import failed with {len(self.errors)} errors: " + "; ".join(map(str, self.errors))

cognite/neat/_utils/text.py

@@ -38,3 +38,25 @@ def humanize_collection(collection: Collection[Any], /, *, sort: bool = True, bi
         sequence = list(strings)
 
     return f"{', '.join(sequence[:-1])} {bind_word} {sequence[-1]}"
+
+
+def title_case(s: str) -> str:
+    """Convert a string to title case, handling underscores and hyphens.
+
+    Args:
+        s: The string to convert.
+    Returns:
+        The title-cased string.
+    Examples:
+        >>> title_case("hello world")
+        'Hello World'
+        >>> title_case("hello_world")
+        'Hello World'
+        >>> title_case("hello-world")
+        'Hello World'
+        >>> title_case("hello_world-and-universe")
+        'Hello World And Universe'
+        >>> title_case("HELLO WORLD")
+        'Hello World'
+    """
+    return " ".join(word.capitalize() for word in s.replace("_", " ").replace("-", " ").split())

cognite/neat/_utils/useful_types.py

@@ -1,7 +1,11 @@
 from collections.abc import Hashable
+from datetime import date, datetime, time, timedelta
 from typing import TypeAlias, TypeVar
 
 JsonVal: TypeAlias = None | str | int | float | bool | dict[str, "JsonVal"] | list["JsonVal"]
 
 
 T_ID = TypeVar("T_ID", bound=Hashable)
+
+# These are the types that openpyxl supports in cells
+CellValueType: TypeAlias = str | int | float | bool | datetime | date | time | timedelta | None

cognite/neat/_utils/validation.py

@@ -31,6 +31,7 @@ def humanize_validation_error(
     humanize_location: Callable[[tuple[int | str, ...]], str] = as_json_path,
     field_name: Literal["field", "column", "value"] = "field",
     field_renaming: Mapping[str, str] | None = None,
+    missing_required_descriptor: Literal["empty", "missing"] = "missing",
 ) -> list[str]:
     """Converts a ValidationError to a human-readable format.
 
@@ -50,6 +51,8 @@ def humanize_validation_error(
             This is useful when the field names in the model are different from the names in the source.
             For example, if the model field is "asset_id" but the source column is "Asset ID",
             you can provide a mapping {"asset_id": "Asset ID"} to have the error messages use the source names.
+        missing_required_descriptor: How to describe missing required fields. Default is "missing".
+            Other option is "empty" which can be more suitable for table data.
     Returns:
         A list of human-readable error messages.
     """
@@ -60,9 +63,9 @@ def humanize_validation_error(
         loc = (*parent_loc, *item["loc"])
         error_type = item["type"]
         if error_type == "missing":
-            msg = f"Missing required field: {loc[-1]!r}"
+            msg = f"Missing required {field_name}: {loc[-1]!r}"
         elif error_type == "extra_forbidden":
-            msg = f"Unused field: {loc[-1]!r}"
+            msg = f"Unused {field_name}: {loc[-1]!r}"
         elif error_type == "value_error":
             msg = str(item["ctx"]["error"])
         elif error_type == "literal_error":
@@ -92,10 +95,10 @@ def humanize_validation_error(
 
         error_suffix = f"{msg[:1].casefold()}{msg[1:]}"
         if len(loc) > 1 and error_type in {"extra_forbidden", "missing"}:
-            if field_name == "column":
+            if missing_required_descriptor == "empty" and error_type == "missing":
                 # This is a table so we modify the error message.
                 msg = (
-                    f"In {humanize_location(loc[:-1])} the column {field_renaming.get(str(loc[-1]), loc[-1])!r} "
+                    f"In {humanize_location(loc[:-1])} the {field_name} {field_renaming.get(str(loc[-1]), loc[-1])!r} "
                     "cannot be empty."
                 )
             else:

cognite/neat/_version.py

@@ -1,2 +1,2 @@
-__version__ = "0.124.0"
+__version__ = "0.125.1"
 __engine__ = "^2.0.4"

cognite/neat/v0/core/_data_model/_constants.py

@@ -43,6 +43,7 @@ class EntityTypes(StrEnum):
     prefix = "prefix"
     space = "space"
     container_index = "container_index"
+    container_constraint = "container_constraint"
     concept_restriction = "conceptRestriction"
     value_constraint = "valueConstraint"
     cardinality_constraint = "cardinalityConstraint"

cognite/neat/v0/core/_data_model/exporters/_data_model2excel.py

@@ -32,7 +32,7 @@ from cognite.neat.v0.core._data_model.models.data_types import (
 )
 from cognite.neat.v0.core._data_model.models.physical._verified import PhysicalDataModel
 from cognite.neat.v0.core._utils.spreadsheet import (
-    find_column_with_value,
+    find_column_and_row_with_value,
     generate_data_validation,
 )
 
@@ -217,7 +217,7 @@ class ExcelExporter(BaseExporter[VerifiedDataModel, Workbook]):
                 continue
             ws = workbook[sheet]
             for col in get_internal_properties():
-                column_letter = find_column_with_value(ws, col)
+                column_letter = find_column_and_row_with_value(ws, col)[0]
                 if column_letter:
                     ws.column_dimensions[column_letter].hidden = True
 
@@ -451,7 +451,7 @@ class ExcelExporter(BaseExporter[VerifiedDataModel, Workbook]):
         workbook[sheet_name].add_data_validation(data_validators[data_validator_name])
 
         # APPLY VALIDATOR TO SPECIFIC COLUMN
-        if column_letter := find_column_with_value(workbook[sheet_name], column_name):
+        if column_letter := find_column_and_row_with_value(workbook[sheet_name], column_name)[0]:
             data_validators[data_validator_name].add(f"{column_letter}{3}:{column_letter}{3 + total_rows}")
 
     def _create_sheet_with_header(

cognite/neat/v0/core/_data_model/importers/_dms2data_model.py

@@ -54,6 +54,7 @@ from cognite.neat.v0.core._data_model.models.entities import (
     ReverseConnectionEntity,
     ViewEntity,
 )
+from cognite.neat.v0.core._data_model.models.entities._single_value import ContainerConstraintEntity
 from cognite.neat.v0.core._data_model.models.physical import (
     UnverifiedPhysicalContainer,
     UnverifiedPhysicalEnum,
@@ -571,17 +572,17 @@ class DMSImporter(BaseImporter[UnverifiedPhysicalDataModel]):
                 index.append(ContainerIndexEntity(prefix="inverted", suffix=index_name, order=order))
         return index or None
 
-    def _get_constraint(self, prop: ViewPropertyApply, prop_id: str) -> list[str] | None:
+    def _get_constraint(self, prop: ViewPropertyApply, prop_id: str) -> list[ContainerConstraintEntity] | None:
         if not isinstance(prop, dm.MappedPropertyApply):
             return None
         container = self._all_containers_by_id[prop.container]
-        unique_constraints: list[str] = []
+        unique_constraints: list[ContainerConstraintEntity] = []
         for constraint_name, constraint_obj in (container.constraints or {}).items():
             if isinstance(constraint_obj, dm.RequiresConstraint):
                 # This is handled in the .from_container method of DMSContainer
                 continue
             elif isinstance(constraint_obj, dm.UniquenessConstraint) and prop_id in constraint_obj.properties:
-                unique_constraints.append(constraint_name)
+                unique_constraints.append(ContainerConstraintEntity(prefix="uniqueness", suffix=constraint_name))
             elif isinstance(constraint_obj, dm.UniquenessConstraint):
                 # This does not apply to this property
                 continue

cognite/neat/v0/core/_data_model/importers/_spreadsheet2data_model.py

@@ -10,8 +10,10 @@ import pandas as pd
 from openpyxl import load_workbook
 from openpyxl.worksheet.worksheet import Worksheet
 from pandas import ExcelFile
+from pydantic import ValidationError
 from rdflib import Namespace, URIRef
 
+from cognite.neat.v0.core._data_model._constants import SPLIT_ON_COMMA_PATTERN
 from cognite.neat.v0.core._data_model._shared import (
     ImportedDataModel,
     T_UnverifiedDataModel,
@@ -23,6 +25,7 @@ from cognite.neat.v0.core._data_model.models import (
     SchemaCompleteness,
 )
 from cognite.neat.v0.core._data_model.models._import_contexts import SpreadsheetContext
+from cognite.neat.v0.core._data_model.models.entities._single_value import ContainerConstraintEntity, ContainerEntity
 from cognite.neat.v0.core._issues import IssueList, MultiValueError
 from cognite.neat.v0.core._issues.errors import (
     FileMissingRequiredFieldError,
@@ -30,7 +33,11 @@ from cognite.neat.v0.core._issues.errors import (
     FileReadError,
 )
 from cognite.neat.v0.core._issues.warnings import FileMissingRequiredFieldWarning
-from cognite.neat.v0.core._utils.spreadsheet import SpreadsheetRead, read_individual_sheet
+from cognite.neat.v0.core._utils.spreadsheet import (
+    SpreadsheetRead,
+    find_column_and_row_with_value,
+    read_individual_sheet,
+)
 from cognite.neat.v0.core._utils.text import humanize_collection
 
 from ._base import BaseImporter
@@ -306,7 +313,7 @@ class ExcelImporter(BaseImporter[T_UnverifiedDataModel]):
 
         """
 
-        workbook = load_workbook(filepath)
+        workbook = load_workbook(filepath, data_only=True)
 
         if "Classes" in workbook.sheetnames:
             print(
@@ -323,13 +330,17 @@ class ExcelImporter(BaseImporter[T_UnverifiedDataModel]):
             if "Properties" in workbook.sheetnames:
                 _replace_class_with_concept_cell(workbook["Properties"])
 
-            with tempfile.NamedTemporaryFile(prefix="temp_neat_file", suffix=".xlsx", delete=False) as temp_file:
-                workbook.save(temp_file.name)
-                return Path(temp_file.name)
+        elif "Containers" in workbook.sheetnames:
+            _replace_legacy_constraint_form(workbook["Containers"])
+            _replace_legacy_constraint_form(workbook["Properties"])
 
         else:
             return filepath
 
+        with tempfile.NamedTemporaryFile(prefix="temp_neat_file", suffix=".xlsx", delete=False) as temp_file:
+            workbook.save(temp_file.name)
+            return Path(temp_file.name)
+
 
 def _replace_class_with_concept_cell(sheet: Worksheet) -> None:
     """
@@ -342,3 +353,72 @@ def _replace_class_with_concept_cell(sheet: Worksheet) -> None:
         for cell in row:
             if cell.value == "Class":
                 cell.value = "Concept"
+
+
+def _replace_legacy_constraint_form(sheet: Worksheet) -> None:
+    """
+    Replaces the legacy form of container constraints with the new form in the given sheet.
+
+    Args:
+        sheet (Worksheet): The sheet in which to replace the old form of container constraints.
+    """
+    column, row = find_column_and_row_with_value(sheet, "Constraint", False)
+
+    if not column or not row:
+        return None
+
+    # Iterate over values in the constraint column and replace old form with new form
+    replaced: bool = False
+    for cell_row in sheet.iter_rows(min_row=row + 1, min_col=column, max_col=column):
+        cell = cell_row[0]
+        if cell.value is not None:  # Skip empty cells
+            # Container sheet update
+            if sheet.title.lower() == "containers":
+                constraints = []
+                for constraint in SPLIT_ON_COMMA_PATTERN.split(str(cell.value)):
+                    # latest format, do nothing
+                    if "container" in constraint.lower():
+                        constraints.append(constraint)
+                        continue
+
+                    try:
+                        container = ContainerEntity.load(constraint, space="default")
+                        container_str = container.external_id if container.space == "default" else str(container)
+                        constraints.append(
+                            f"requires:{container.space}_{container.external_id}(container={container_str})"
+                        )
+                        replaced = True
+                    except ValidationError:
+                        constraints.append(constraint)
+
+                cell.value = ",".join(constraints)
+
+            # Properties sheet update
+            elif sheet.title.lower() == "properties":
+                constraints = []
+                for constraint in SPLIT_ON_COMMA_PATTERN.split(str(cell.value)):
+                    try:
+                        constraint_entity = ContainerConstraintEntity.load(constraint)
+
+                        if constraint_entity.prefix in ["uniqueness", "requires"]:
+                            constraints.append(constraint)
+
+                        # Replace old format with new format
+                        else:
+                            constraints.append(f"uniqueness:{constraint}")
+                            replaced = True
+
+                    # If the constraint is not valid, we keep it as is
+                    # to be caught by validation later
+                    except ValidationError:
+                        constraints.append(constraint)
+
+                cell.value = ",".join(constraints)
+
+    if replaced:
+        print(
+            (
+                "You are using a legacy container constraints format "
+                f"in the {sheet.title} sheet. Please update to the latest format."
+            ),
+        )

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

@@ -7,6 +7,7 @@ from ._single_value import (
     AssetFields,
     ConceptEntity,
     ConceptualEntity,
+    ContainerConstraintEntity,
     ContainerEntity,
     ContainerIndexEntity,
     DataModelEntity,
@@ -35,6 +36,7 @@ __all__ = [
     "ConceptPropertyCardinalityConstraint",
     "ConceptPropertyValueConstraint",
     "ConceptualEntity",
+    "ContainerConstraintEntity",
     "ContainerEntity",
     "ContainerEntityList",
     "ContainerIndexEntity",

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

@@ -660,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
+    container: ContainerEntity | None = None
+
+    def as_id(self) -> None:
+        return None
+
+    @classmethod
+    def from_id(cls, id: None) -> Self:
+        return cls(suffix="dummy")