cognite-neat 0.124.0__py3-none-any.whl → 0.125.0__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.0"
 __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")

cognite/neat/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/v0/core/_data_model/models/physical/_exporter.py

@@ -1,4 +1,3 @@
-import hashlib
 import warnings
 from collections import defaultdict
 from collections.abc import Collection, Hashable, Sequence
@@ -26,7 +25,6 @@ from cognite.neat.v0.core._constants import (
     DMS_DIRECT_RELATION_LIST_DEFAULT_LIMIT,
     DMS_PRIMITIVE_LIST_DEFAULT_LIMIT,
 )
-from cognite.neat.v0.core._data_model._constants import CONSTRAINT_ID_MAX_LENGTH
 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,
@@ -381,7 +379,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))
@@ -411,19 +410,12 @@ class _DMSExporter:
         for container in containers:
             if container.constraints:
                 container.constraints = {
-                    self._truncate_constraint_name(name): const
+                    name: const
                     for name, const in container.constraints.items()
                     if not (isinstance(const, dm.RequiresConstraint) and const.require in container_to_drop)
                 }
         return ContainerApplyDict([container for container in containers if container.as_id() not in container_to_drop])
 
-    @staticmethod
-    def _truncate_constraint_name(name: str) -> str:
-        if len(name) <= CONSTRAINT_ID_MAX_LENGTH:
-            return name
-        half_length = int(CONSTRAINT_ID_MAX_LENGTH / 2)
-        return f"{name[: half_length - 1]}{hashlib.md5(name.encode()).hexdigest()[:half_length]}"
-
     @staticmethod
     def _gather_properties(
         properties: Sequence[PhysicalProperty],

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

@@ -21,6 +21,7 @@ from cognite.neat.v0.core._data_model.models._base_unverified 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,
@@ -138,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
 
@@ -197,6 +198,8 @@ class UnverifiedPhysicalProperty(UnverifiedComponent[PhysicalProperty]):
                 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:
@@ -249,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
 
@@ -260,14 +263,7 @@ 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, return_on_failure=True)
-        output["Constraint"] = (
-            [
-                ContainerEntity.load(constraint.strip(), space=default_space, return_on_failure=True)
-                for constraint in self.constraint.split(",")
-            ]
-            if self.constraint
-            else None
-        )
+        output["Constraint"] = _parse_constraints(self.constraint, default_space)
         return output
 
     @overload
@@ -286,9 +282,13 @@ class UnverifiedPhysicalContainer(UnverifiedComponent[PhysicalContainer]):
     @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, container=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(
@@ -506,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/v0/core/_data_model/models/physical/_validation.py

@@ -3,6 +3,7 @@ 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
@@ -121,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.container not in existing_containers:
+                    imported_containers.add(cast(ContainerEntity, constraint.container))
 
         if include_views_with_no_properties:
             extra_views = existing_views - view_with_properties
@@ -470,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](

cognite/neat/v0/core/_data_model/models/physical/_verified.py

@@ -10,6 +10,7 @@ from pydantic_core.core_schema import SerializationInfo, ValidationInfo
 
 from cognite.neat.v0.core._client.data_classes.schema import DMSSchema
 from cognite.neat.v0.core._constants import DMS_CONTAINER_LIST_MAX_LIMIT
+from cognite.neat.v0.core._data_model._constants import CONSTRAINT_ID_MAX_LENGTH
 from cognite.neat.v0.core._data_model.models._base_verified import (
     BaseVerifiedDataModel,
     BaseVerifiedMetadata,
@@ -25,7 +26,6 @@ from cognite.neat.v0.core._data_model.models._types import (
     ConceptEntityType,
     ContainerEntityType,
     PhysicalPropertyType,
-    StrListType,
     URIRefType,
     ViewEntityType,
 )
@@ -45,7 +45,10 @@ from cognite.neat.v0.core._data_model.models.entities import (
     ViewEntity,
     ViewEntityList,
 )
-from cognite.neat.v0.core._data_model.models.entities._types import ContainerEntityList, ContainerIndexListType
+from cognite.neat.v0.core._data_model.models.entities._types import (
+    ContainerConstraintListType,
+    ContainerIndexListType,
+)
 from cognite.neat.v0.core._issues.errors import NeatValueError
 from cognite.neat.v0.core._issues.warnings import NeatValueWarning, PropertyDefinitionWarning
 
@@ -149,7 +152,7 @@ class PhysicalProperty(SheetRow):
         alias="Index",
         description="The names of the indexes (comma separated) that should be created for the property.",
     )
-    constraint: StrListType | None = Field(
+    constraint: ContainerConstraintListType | None = Field(
         None,
         alias="Constraint",
         description="The names of the uniquness (comma separated) that should be created for the property.",
@@ -264,11 +267,12 @@ class PhysicalProperty(SheetRow):
     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
+
+        container = info.data["container"]
+        container_property = info.data["container_property"]
+
+        if not container or not container_property:
+            raise ValueError("Container and container property must be set to use indexes")
         max_count = info.data.get("max_count")
         is_list = (
             max_count is not None and (isinstance(max_count, int | float) and max_count > 1)
@@ -277,7 +281,7 @@ class PhysicalProperty(SheetRow):
             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),
+                    PropertyDefinitionWarning(str(container), "container property", str(container_property), message),
                     stacklevel=2,
                 )
             elif index.prefix == "inverted" and not is_list:
@@ -286,7 +290,7 @@ class PhysicalProperty(SheetRow):
                     "Please consider using btree index instead."
                 )
                 warnings.warn(
-                    PropertyDefinitionWarning(container, "container property", container_property, message),
+                    PropertyDefinitionWarning(str(container), "container property", str(container_property), message),
                     stacklevel=2,
                 )
             elif index.prefix == "btree" and is_list:
@@ -295,17 +299,49 @@ class PhysicalProperty(SheetRow):
                     "Please consider using inverted index instead."
                 )
                 warnings.warn(
-                    PropertyDefinitionWarning(container, "container property", container_property, message),
+                    PropertyDefinitionWarning(str(container), "container property", str(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),
+                    PropertyDefinitionWarning(str(container), "container property", str(container_property), message),
                     stacklevel=2,
                 )
         return value
 
+    @field_validator("constraint", mode="after")
+    @classmethod
+    def constraint_set_correctly(cls, value: ContainerConstraintListType | None, info: ValidationInfo) -> Any:
+        if value is None:
+            return value
+
+        container = info.data["container"]
+        container_property = info.data["container_property"]
+
+        if not container or not container_property:
+            raise ValueError("Container and container property must be set to use constraint")
+
+        for constraint in value:
+            if constraint.prefix is Undefined:
+                message = f"The type of constraint is not defined. Please set 'uniqueness:{constraint!s}'."
+                warnings.warn(
+                    PropertyDefinitionWarning(str(container), "container property", str(container_property), message),
+                    stacklevel=2,
+                )
+            elif constraint.prefix != "uniqueness":
+                message = (
+                    f"Unsupported constraint type on container property"
+                    f" '{constraint.prefix}'. Currently only 'uniqueness' is supported."
+                )
+                raise ValueError(message) from None
+
+            if len(constraint.suffix) > CONSTRAINT_ID_MAX_LENGTH:
+                message = f"Constraint id '{constraint.suffix}' exceeds maximum length of {CONSTRAINT_ID_MAX_LENGTH}."
+                raise ValueError(message) from None
+
+        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):
@@ -352,13 +388,46 @@ class PhysicalContainer(SheetRow):
     description: str | None = Field(
         alias="Description", default=None, description="Short description of the node being defined."
     )
-    constraint: ContainerEntityList | None = Field(
+    constraint: ContainerConstraintListType | None = Field(
         None, alias="Constraint", description="List of required (comma separated) constraints for the container"
     )
     used_for: Literal["node", "edge", "all"] | None = Field(
         "all", alias="Used For", description=" Whether the container is used for nodes, edges or all."
     )
 
+    @field_validator("constraint", mode="after")
+    @classmethod
+    def constraint_set_correctly(cls, value: ContainerConstraintListType | None) -> Any:
+        if value is None:
+            return value
+
+        for constraint in value:
+            if constraint.prefix is Undefined:
+                message = f"The type of constraint is not defined. Please set 'requires:{constraint!s}'."
+                warnings.warn(
+                    message,
+                    stacklevel=2,
+                )
+            elif constraint.prefix != "requires":
+                message = (
+                    f"Unsupported constraint type on container as "
+                    f"the whole '{constraint.prefix}'. Currently only 'requires' is supported."
+                )
+                raise ValueError(message) from None
+
+            if len(constraint.suffix) > CONSTRAINT_ID_MAX_LENGTH:
+                message = f"Constraint id '{constraint.suffix}' exceeds maximum length of {CONSTRAINT_ID_MAX_LENGTH}."
+                raise ValueError(message) from None
+
+            if constraint.container is None:
+                message = (
+                    f"Container constraint must have a container set. "
+                    f"Please set 'requires:{constraint!s}(container=space:external_id)'."
+                )
+                raise ValueError(message) from None
+
+        return value
+
     def _identifier(self) -> tuple[Hashable, ...]:
         return (self.container,)
 
@@ -366,8 +435,10 @@ class PhysicalContainer(SheetRow):
         container_id = self.container.as_id()
         constraints: dict[str, dm.Constraint] = {}
         for constraint in self.constraint or []:
-            requires = dm.RequiresConstraint(constraint.as_id())
-            constraints[f"{constraint.space}_{constraint.external_id}"] = requires
+            if constraint.container is None:
+                continue
+            requires = dm.RequiresConstraint(constraint.container.as_id())
+            constraints[constraint.suffix] = requires
 
         return dm.ContainerApply(
             space=container_id.space,

cognite/neat/v0/core/_data_model/transformers/_converters.py

@@ -29,7 +29,7 @@ from cognite.neat.v0.core._constants import (
     DMS_RESERVED_PROPERTIES,
     get_default_prefixes_and_namespaces,
 )
-from cognite.neat.v0.core._data_model._constants import PATTERNS, get_reserved_words
+from cognite.neat.v0.core._data_model._constants import CONSTRAINT_ID_MAX_LENGTH, PATTERNS, get_reserved_words
 from cognite.neat.v0.core._data_model._shared import (
     ImportContext,
     ImportedDataModel,
@@ -72,6 +72,7 @@ from cognite.neat.v0.core._data_model.models.entities import (
     UnknownEntity,
     ViewEntity,
 )
+from cognite.neat.v0.core._data_model.models.entities._single_value import ContainerConstraintEntity
 from cognite.neat.v0.core._data_model.models.physical import (
     PhysicalMetadata,
     PhysicalProperty,
@@ -1638,14 +1639,20 @@ class _ConceptualDataModelConverter:
         default_space: str,
         concept_by_concept_entity: dict[ConceptEntity, Concept],
         referenced_containers: Collection[ContainerEntity],
-    ) -> list[ContainerEntity]:
-        constrains: list[ContainerEntity] = []
+    ) -> list[ContainerConstraintEntity]:
+        constrains: list[ContainerConstraintEntity] = []
         for entity in concept_entities:
             concept = concept_by_concept_entity[entity]
             for parent in concept.implements or []:
                 parent_entity = parent.as_container_entity(default_space)
                 if parent_entity in referenced_containers:
-                    constrains.append(parent_entity)
+                    constrains.append(
+                        ContainerConstraintEntity(
+                            prefix="requires",
+                            suffix=f"{parent_entity.space}_{parent_entity.external_id}"[:CONSTRAINT_ID_MAX_LENGTH],
+                            container=parent_entity,
+                        )
+                    )
         return constrains
 
     @classmethod

cognite/neat/v0/core/_utils/spreadsheet.py

@@ -143,13 +143,27 @@ def _get_row_number(sheet: Worksheet, values_to_find: list[str]) -> int | None:
     return None
 
 
-def find_column_with_value(sheet: Worksheet, value: Any) -> str | None:
+@overload
+def find_column_and_row_with_value(
+    sheet: Worksheet, value: Any, column_letter: Literal[True] = True
+) -> tuple[str, int] | tuple[None, None]: ...
+
+
+@overload
+def find_column_and_row_with_value(
+    sheet: Worksheet, value: Any, column_letter: Literal[False]
+) -> tuple[int, int] | tuple[None, None]: ...
+
+
+def find_column_and_row_with_value(
+    sheet: Worksheet, value: Any, column_letter: bool = True
+) -> tuple[int, int] | tuple[str, int] | tuple[None, None]:
     for row in sheet.iter_rows():
         for cell in row:
             if cell.value and isinstance(cell.value, str) and cell.value.lower() == value.lower():
-                return cell.column_letter  # type: ignore
+                return (cell.column_letter, cell.row) if column_letter else (cell.column, cell.row)
 
-    return None
+    return None, None
 
 
 def generate_data_validation(sheet: str, column: str, total_header_rows: int, validation_range: int) -> DataValidation:

{cognite_neat-0.124.0.dist-info → cognite_neat-0.125.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 0.124.0
+Version: 0.125.0
 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.124.0.dist-info → cognite_neat-0.125.0.dist-info}/RECORD

@@ -1,12 +1,17 @@
 cognite/neat/__init__.py,sha256=Lo4DbjDOwnhCYUoAgPp5RG1fDdF7OlnomalTe7n1ydw,211
+cognite/neat/_exceptions.py,sha256=IvDKO8kHk4dCkrmQU6z_svJcPqs2m7QYLosuOuM_iwE,473
 cognite/neat/_issues.py,sha256=uv0fkkWwTKqNmTmHqyoBB3L6yMCh42EZpEkLGmIJYOY,812
-cognite/neat/_version.py,sha256=0GwMYSFb5nGMLM9dHslSjNFrEuvigs26DxXB6nxHwqk,46
+cognite/neat/_version.py,sha256=uGBcX4xuE__guAX0yJVFt4XCMymM1MTnVvYJi0BG7QM,46
 cognite/neat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/_data_model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/_data_model/_constants.py,sha256=NGGvWHlQqhkkSBP_AqoofGYjNph3SiZX6QPINlMsy04,107
 cognite/neat/_data_model/_identifiers.py,sha256=a0LcQ_h0NffxSKTCrzCDpYkrlaUTk-D_rfaQUh-BhWc,1921
-cognite/neat/_data_model/importers/__init__.py,sha256=GUp7WkjX6R02lQRHD-2ygkwNGPSWbFjrFettnCdrrAQ,58
+cognite/neat/_data_model/importers/__init__.py,sha256=Ntk6Z8jpPvr7awV4kgs-uMRB2RrA3ufi0O7sSMgcv0o,133
 cognite/neat/_data_model/importers/_base.py,sha256=NRB0FcEBj4GaethU68nRffBfTedBBA866A3zfJNfmiQ,433
+cognite/neat/_data_model/importers/_table_importer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cognite/neat/_data_model/importers/_table_importer/data_classes.py,sha256=c_P4j7cHTyltNRiNzJJkJ-TKM5uoiizyLI6cgvLA3nM,4057
+cognite/neat/_data_model/importers/_table_importer/importer.py,sha256=aBO8CBHCAeZJbNa7LPt4JfZMb558nKu5KT9aXhp2vvs,3245
+cognite/neat/_data_model/importers/_table_importer/source.py,sha256=CU6kHJquKxDgYSMwONALbl6yleF_FoAgGU2SXl_uj0Y,3098
 cognite/neat/_data_model/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/_data_model/models/conceptual/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/_data_model/models/conceptual/_base.py,sha256=SFkoBJDM51pqew_isHFJoB20OgfofpwVRnTrg-rKkNY,710
@@ -41,9 +46,9 @@ cognite/neat/_session/_state_machine/_base.py,sha256=gdk1uIj--f50v2_X9zxqFRYTXiC
 cognite/neat/_session/_state_machine/_states.py,sha256=RX6C0YNNT9mX0C6c-ZTiUVh6pmMT5ZNXiOuSs80vVXU,4853
 cognite/neat/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/_utils/auxiliary.py,sha256=Cx-LP8dfN782R3iUcm--q26zdzQ0k_RFnVbJ0bwVZMI,1345
-cognite/neat/_utils/text.py,sha256=1el5Ty1T0tdhTF0gp6L8AAzUxaFmAUAIFy_VvfG_kkM,1194
-cognite/neat/_utils/useful_types.py,sha256=6Fpw_HlWFj8ZYjGPd0KzguBczuI8GFhj5wBceGsaeak,211
-cognite/neat/_utils/validation.py,sha256=Rwd-oABdnHyiwd2WR1H4F2JYTdshNIKzHqErbo-MDns,5113
+cognite/neat/_utils/text.py,sha256=tDspKjU4AkzB6P1kKPNaVpx-yvx3V2uQVC3FAr6nibM,1835
+cognite/neat/_utils/useful_types.py,sha256=3qVfeQXg0xCcSEG7RymYU84LDbk0joKzruFY9EKAX8g,415
+cognite/neat/_utils/validation.py,sha256=vS7GAvMMeco1jUaEs_Rz2pUoz28uee6xU4yt8CrCzE4,5430
 cognite/neat/_utils/http_client/__init__.py,sha256=gJBrOH1tIzEzLforHbeakYimTn4RlelyANps-jtpREI,894
 cognite/neat/_utils/http_client/_client.py,sha256=2RVwTbbPFlQ8eJVLKNUXwnc4Yq_783PkY44zwr6LlT8,11509
 cognite/neat/_utils/http_client/_config.py,sha256=C8IF1JoijmVMjA_FEMgAkiD1buEV1cY5Og3t-Ecyfmk,756
@@ -68,7 +73,7 @@ cognite/neat/v0/core/_client/data_classes/neat_sequence.py,sha256=QZWSfWnwk6KlYJ
 cognite/neat/v0/core/_client/data_classes/schema.py,sha256=YoLm0YQIhbYSFuSgC-GB3jgNy7qZw4WhT3A-jKkIVhk,25079
 cognite/neat/v0/core/_client/data_classes/statistics.py,sha256=GU-u41cOTig0Y5pYhW5KqzCsuAUIX9tOmdizMEveYuw,4487
 cognite/neat/v0/core/_data_model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cognite/neat/v0/core/_data_model/_constants.py,sha256=BEzWHWnEmtkYSPJVcGv3rL7JuYIZZNeI4Y5IUhtqTFk,6071
+cognite/neat/v0/core/_data_model/_constants.py,sha256=oNgFTYEQm1yjpUWhWlY9bVjoZ4odXOLQK0r_kGllNOA,6121
 cognite/neat/v0/core/_data_model/_shared.py,sha256=ug6B_Vz7seg464xMMn0v3SKN_FNCNG1QeLqW-Bto-yA,2100
 cognite/neat/v0/core/_data_model/analysis/__init__.py,sha256=v3hSfz7AEEqcmdjL71I09tP8Hl-gPZYOiDYMp_CW4vg,70
 cognite/neat/v0/core/_data_model/analysis/_base.py,sha256=AfaKN-NlrXT5J-Tf3CuVzZHwbJXuJbdXwFRJ9uGI_Qg,24472
@@ -79,7 +84,7 @@ cognite/neat/v0/core/_data_model/catalog/hello_world_pump.xlsx,sha256=E63t5U1PQL
 cognite/neat/v0/core/_data_model/exporters/__init__.py,sha256=NSTeVtfgfkfrhf_Ruz5rHnlF0wIj2dIhAm3io1tEIkQ,1153
 cognite/neat/v0/core/_data_model/exporters/_base.py,sha256=pdtQDi5G89JVbHtGnvLHJDoujT1UVaCBw939Re1Gqv4,2412
 cognite/neat/v0/core/_data_model/exporters/_data_model2dms.py,sha256=LdLGgR73n9k5hHiWUSdvDc0lmaEO8UVQYFTiaVWHQ-c,19918
-cognite/neat/v0/core/_data_model/exporters/_data_model2excel.py,sha256=dT7ZHt57y3mca4TtCBnqMER0xlB7AyvivG0EZ2bGPzg,25484
+cognite/neat/v0/core/_data_model/exporters/_data_model2excel.py,sha256=Oba2Cj81QNNxnSVX4-xxwyysGeAUPqUaf9oHEnpQjAc,25514
 cognite/neat/v0/core/_data_model/exporters/_data_model2instance_template.py,sha256=cmyQBlc1UM5l42g1N_F2K1sVu39ontsmA2bfXJO5muQ,6115
 cognite/neat/v0/core/_data_model/exporters/_data_model2semantic_model.py,sha256=vxeDEWyvj7uv6geNlTQe6MfGcNZkeQJYz0vLzPI7e14,23154
 cognite/neat/v0/core/_data_model/exporters/_data_model2yaml.py,sha256=v7CgNVtVv4t0FXHPJM-HGkID0AqVDlwsQqUNjWqr_1U,3287
@@ -87,9 +92,9 @@ cognite/neat/v0/core/_data_model/importers/__init__.py,sha256=jkDKSGv5VdJgl44lmn
 cognite/neat/v0/core/_data_model/importers/_base.py,sha256=SAC3nhJUBBl5PwnIs-bQvVam_0zEGjlOlNMvVOuJZzI,2028
 cognite/neat/v0/core/_data_model/importers/_base_file_reader.py,sha256=OjjXb0IOlu69PXrhwH9EH4jbwNFwyKfYOQR0WnuwqO4,1627
 cognite/neat/v0/core/_data_model/importers/_dict2data_model.py,sha256=CeDZNAO4W5JZmrboYtTfHnuU1UoXRI2nOUaasWmxfqM,4720
-cognite/neat/v0/core/_data_model/importers/_dms2data_model.py,sha256=CuZk9BiD-y3n0sZGDxByGTK3frI0pSjIn6mr6djj7lY,29357
+cognite/neat/v0/core/_data_model/importers/_dms2data_model.py,sha256=yXQucBtmJLzEHKly2RcOB-g2iiAyM_h4jFbVT-38gHM,29557
 cognite/neat/v0/core/_data_model/importers/_graph2data_model.py,sha256=ILgrhror8PUpwKT9Q9Y8XO_rLSe4qPV4v7jvltjhzeM,13720
-cognite/neat/v0/core/_data_model/importers/_spreadsheet2data_model.py,sha256=YySY5LxnyD6xwEmg4UqWvc9TfErHUDaJ0d-vM2IUVbc,12103
+cognite/neat/v0/core/_data_model/importers/_spreadsheet2data_model.py,sha256=qsvb4cA93VpTfMATaVnZyXs-hpzTfxl8jwGk5cpp3k0,15437
 cognite/neat/v0/core/_data_model/importers/_rdf/__init__.py,sha256=1yOjV2PKCxwH7uCTXVZhSdxtn5etmFX40cksvwtKcZ8,199
 cognite/neat/v0/core/_data_model/importers/_rdf/_base.py,sha256=Rv24TQQDZqAuFD8Qh0yRBiB7-JvoMVj3mGoPBm-xBFs,6052
 cognite/neat/v0/core/_data_model/importers/_rdf/_inference2rdata_model.py,sha256=w8LsdkzgoTXN3LZyjEL_5grWZGlf7PPj8qOu370_K6M,28976
@@ -105,25 +110,25 @@ cognite/neat/v0/core/_data_model/models/conceptual/__init__.py,sha256=9A6myEV8s0
 cognite/neat/v0/core/_data_model/models/conceptual/_unverified.py,sha256=UvqjGxVQsf_cNCYf726TXgnPplUy3iBuI-nUp0TclD0,6539
 cognite/neat/v0/core/_data_model/models/conceptual/_validation.py,sha256=oaXRe1RfwsCQ_D5-IdXJf6yZ4Eug_PLu-bDklADYGV4,13895
 cognite/neat/v0/core/_data_model/models/conceptual/_verified.py,sha256=8-H535sx-V11cNyuVOHImqWga8CsqcjPvXfwp0PclBQ,13743
-cognite/neat/v0/core/_data_model/models/entities/__init__.py,sha256=qXrnTygYBgu4iE-ehNsHwmZ89pm9pTfU_Qe9rAq-ldg,1789
+cognite/neat/v0/core/_data_model/models/entities/__init__.py,sha256=pDnSy0k2WmoGuvzyLmXimH3IDA6pjO0bO0aEse2TC3o,1853
 cognite/neat/v0/core/_data_model/models/entities/_constants.py,sha256=GXRzVfArwxF3C67VCkzy0JWTZRkRJUYXBQaaecrqcWc,351
 cognite/neat/v0/core/_data_model/models/entities/_loaders.py,sha256=6UD1ik4juMh-yW9cEEnXuheV1vwopdM6d_BBpyUOUUY,5709
 cognite/neat/v0/core/_data_model/models/entities/_multi_value.py,sha256=lkQ95o3Tvf7QImDq8d6KYfgYyq4_zQCqVBAZDOdK2TY,2798
 cognite/neat/v0/core/_data_model/models/entities/_restrictions.py,sha256=wjA6GpfL1FGIjsf6Mo6Rj9Ht-gRnBvOkhj_waN2w2p4,8943
-cognite/neat/v0/core/_data_model/models/entities/_single_value.py,sha256=LS4Zi5iT4WcCrDadwlxAa8cNvA6ucjFf3Mi0cEfbWQg,23972
-cognite/neat/v0/core/_data_model/models/entities/_types.py,sha256=MqrCovqI_nvpMB4UqiUk4eUlKANvr8P7wr8k3y8lXlQ,2183
+cognite/neat/v0/core/_data_model/models/entities/_single_value.py,sha256=ou6adX0-h7PVN7_6IrvP8WXoCDpstTkq7C9Yh_scaZU,24404
+cognite/neat/v0/core/_data_model/models/entities/_types.py,sha256=ZmtRvQf4Ghhf4hDnKbZeQq4tZyj5NcQngtw8GeZYa_k,2432
 cognite/neat/v0/core/_data_model/models/entities/_wrapped.py,sha256=hOvdyxCNFgv1UdfaasviKnbEN4yN09Iip0ggQiaXgB4,7993
 cognite/neat/v0/core/_data_model/models/mapping/__init__.py,sha256=T68Hf7rhiXa7b03h4RMwarAmkGnB-Bbhc1H07b2PyC4,100
 cognite/neat/v0/core/_data_model/models/mapping/_classic2core.py,sha256=F0zusTh9pPR4z-RExPw3o4EMBSU2si6FJLuej2a3JzM,1430
 cognite/neat/v0/core/_data_model/models/mapping/_classic2core.yaml,sha256=ei-nuivNWVW9HmvzDBKIPF6ZdgaMq64XHw_rKm0CMxg,22584
 cognite/neat/v0/core/_data_model/models/physical/__init__.py,sha256=pH5ZF8jiW0A2w7VCSoHUsXxe894QFvTtgjxXNGVVaxk,990
-cognite/neat/v0/core/_data_model/models/physical/_exporter.py,sha256=Dfll4NU5roUCCvjZ5_q25SYjZntCl5LucuH5Fr4JjQY,30744
-cognite/neat/v0/core/_data_model/models/physical/_unverified.py,sha256=7la586tAfj7a1_Ql8-Z_amf5mFeBXjAJ57bVdNggIrE,20140
-cognite/neat/v0/core/_data_model/models/physical/_validation.py,sha256=I954pfdIA2OWAwQP7foyNa6FBJUVB3U-aqf6Likoqp0,41188
-cognite/neat/v0/core/_data_model/models/physical/_verified.py,sha256=WU0HV8coZfRw-XIEVJZl9PxUaY0Y6q75fBoUF2MgwU4,26813
+cognite/neat/v0/core/_data_model/models/physical/_exporter.py,sha256=ega1Yyosq-D9XYCypx9wtuMTFwS0EMRo_e3JwW434XU,30335
+cognite/neat/v0/core/_data_model/models/physical/_unverified.py,sha256=ZhxKGVM_wyl8uNFspsoNs9uSD0SVE1HO9HcRy2ffzDQ,22421
+cognite/neat/v0/core/_data_model/models/physical/_validation.py,sha256=wxk65FrF5u_OwT28yB1tQHwRwkjj5Q938P6_b9RMIsA,41330
+cognite/neat/v0/core/_data_model/models/physical/_verified.py,sha256=J0HNOAlAm2WNlNI0EcOaBOI-mJxUHghs2BIgLYevSbM,29830
 cognite/neat/v0/core/_data_model/transformers/__init__.py,sha256=N6yRBplAkrwwxoTAre_1BE_fdSZL5jihr7xTQjW3KnM,1876
 cognite/neat/v0/core/_data_model/transformers/_base.py,sha256=3ZO73A3xIAFUAyH4U682CbPUmZLPUB8HpWGpYvVbRBQ,3145
-cognite/neat/v0/core/_data_model/transformers/_converters.py,sha256=9Y8-94Vo0wfFjZvyumFzty-sNBo_1gt-FSHazjfb21E,111594
+cognite/neat/v0/core/_data_model/transformers/_converters.py,sha256=vgypwPCI14DtKDl3WdXzuFxH1bgxH-7yLG-Ytvjo0MM,112042
 cognite/neat/v0/core/_data_model/transformers/_mapping.py,sha256=6R4QVblqivI1NvI0iSG5xC7fGHrdZcxqRg3c2Zx5o2E,19045
 cognite/neat/v0/core/_data_model/transformers/_union_conceptual.py,sha256=Dp8Oe6i2duihwDWnGnfPEXRExyKIMiFM_XEcr0U9IbE,8867
 cognite/neat/v0/core/_data_model/transformers/_verification.py,sha256=rIsmrmHvCgEddpPFIEXMMbRb9x9m3jCBi184g3JcrNA,5214
@@ -200,7 +205,7 @@ cognite/neat/v0/core/_utils/collection_.py,sha256=hYyvje47AAvY7sCmZy0NouX1OMVKLh
 cognite/neat/v0/core/_utils/graph_transformations_report.py,sha256=-V0LM9BI_bHT6PTTG9Qby4PGtFkYU3cxtF0cz8KoKek,1238
 cognite/neat/v0/core/_utils/io_.py,sha256=D2Mg8sOxfBoDg3fC0jBzaxO3vkXmr0QvZSgYIv6xRkM,386
 cognite/neat/v0/core/_utils/rdf_.py,sha256=ccnKqLPyKyZ44KknsN3kpCf-DkjSHSqX2KMreFN4Dlc,11226
-cognite/neat/v0/core/_utils/spreadsheet.py,sha256=wQWL8XJ8cRxWi_Y4oiDyEB2w1DICU9h6OvFCPLYZipg,5954
+cognite/neat/v0/core/_utils/spreadsheet.py,sha256=lc8lO1v6PIRZ7s0sFBqUOzDGRD1JhsuW-zSghC-xnqE,6409
 cognite/neat/v0/core/_utils/tarjan.py,sha256=IZvwaIITryGVNbo9Bv5EA9_sW3DyfUNAe7uYyPOCL0g,1357
 cognite/neat/v0/core/_utils/text.py,sha256=3Dkz_lmGOHHJ_LKnd1GM_wrGHUWXsXse0Us2BAW5fUI,8522
 cognite/neat/v0/core/_utils/time_.py,sha256=7ayUm0OWZm1JDmy32E4ip8WRr2o0GLwrHwJA8sJ43Z4,357
@@ -239,7 +244,7 @@ cognite/neat/v0/session/engine/__init__.py,sha256=D3MxUorEs6-NtgoICqtZ8PISQrjrr4
 cognite/neat/v0/session/engine/_import.py,sha256=1QxA2_EK613lXYAHKQbZyw2yjo5P9XuiX4Z6_6-WMNQ,169
 cognite/neat/v0/session/engine/_interface.py,sha256=3W-cYr493c_mW3P5O6MKN1xEQg3cA7NHR_ev3zdF9Vk,533
 cognite/neat/v0/session/engine/_load.py,sha256=u0x7vuQCRoNcPt25KJBJRn8sJabonYK4vtSZpiTdP4k,5201
-cognite_neat-0.124.0.dist-info/METADATA,sha256=uQiuJcVRVFPhAyKUSXFn7DyXW8kfBE75pCQgnZxU8Ec,9147
-cognite_neat-0.124.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cognite_neat-0.124.0.dist-info/licenses/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
-cognite_neat-0.124.0.dist-info/RECORD,,
+cognite_neat-0.125.0.dist-info/METADATA,sha256=7ivvPpgIWACTNikYCjpnMN88v2kbu9G3JNIhGL3oTgQ,9147
+cognite_neat-0.125.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cognite_neat-0.125.0.dist-info/licenses/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
+cognite_neat-0.125.0.dist-info/RECORD,,