cognite-neat 0.125.0__py3-none-any.whl → 0.126.0__py3-none-any.whl

cognite/neat/_data_model/exporters/_base.py

@@ -0,0 +1,17 @@
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar
+
+from cognite.neat._data_model.models.dms import RequestSchema
+
+T_Export = TypeVar("T_Export")
+
+
+class DMSExporter(ABC, Generic[T_Export]):
+    """This is the base class for all DMS exporters."""
+
+    NEW_LINE = "\n"
+    ENCODING = "utf-8"
+
+    @abstractmethod
+    def export(self, data_model: RequestSchema) -> T_Export:
+        raise NotImplementedError()

cognite/neat/_data_model/exporters/_table_exporter.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+
+from cognite.neat._data_model.models.dms import RequestSchema
+from cognite.neat._utils.useful_types import DataModelTableType
+
+from ._base import DMSExporter
+
+
+class DMSTableExporter(DMSExporter[DataModelTableType]):
+    """Exports DMS to a table structure.
+
+    The tables 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.
+    """
+
+    def export(self, data_model: RequestSchema) -> DataModelTableType:
+        raise NotImplementedError()
+
+    def as_excel(self, data_model: RequestSchema, file_path: Path) -> None:
+        """Exports the data model as an Excel file.
+
+        Args:
+            data_model (RequestSchema): The data model to export.
+            file_path (Path): The path to the Excel file to create.
+        """
+        raise NotImplementedError()
+
+    def as_yaml(self, data_model: RequestSchema, file_path: Path) -> None:
+        """Exports the data model as a YAML file.
+
+        Args:
+            data_model (RequestSchema): The data model to export.
+            file_path (Path): The path to the YAML file to create.
+        """
+        raise NotImplementedError()

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

@@ -9,10 +9,13 @@ from cognite.neat._data_model.models.dms import (
 )
 from cognite.neat._exceptions import DataModelImportError
 from cognite.neat._issues import ModelSyntaxError
-from cognite.neat._utils.useful_types import CellValueType
+from cognite.neat._utils.text import humanize_collection
+from cognite.neat._utils.useful_types import DataModelTableType
 from cognite.neat._utils.validation import as_json_path, humanize_validation_error
 
-from .data_classes import TableDMS
+from .data_classes import MetadataValue, TableDMS
+from .reader import DMSTableReader
+from .source import TableSource
 
 
 class DMSTableImporter(DMSImporter):
@@ -30,11 +33,16 @@ class DMSTableImporter(DMSImporter):
         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:
+    def __init__(self, tables: DataModelTableType, source: TableSource | None = None) -> None:
         self._table = tables
+        self._source = source or TableSource("Unknown")
 
     def to_data_model(self) -> RequestSchema:
-        raise NotImplementedError()
+        tables = self._read_tables()
+
+        space, version = self._read_defaults(tables.metadata)
+        reader = DMSTableReader(space, version, self._source)
+        return reader.read_tables(tables)
 
     def _read_tables(self) -> TableDMS:
         try:
@@ -74,3 +82,22 @@ class DMSTableImporter(DMSImporter):
             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)
+
+    @staticmethod
+    def _read_defaults(metadata: list[MetadataValue]) -> tuple[str, str]:
+        """Reads the space and version from the metadata table."""
+        default_space: str | None = None
+        default_version: str | None = None
+        missing = {"space", "version"}
+        for meta in metadata:
+            if meta.key == "space":
+                default_space = str(meta.value)
+                missing.remove("space")
+            elif meta.key == "version":
+                default_version = str(meta.value)
+                missing.remove("version")
+        if missing:
+            error = ModelSyntaxError(message=f"In Metadata missing required values: {humanize_collection(missing)}")
+            # If space or version is missing, we cannot continue parsing the model as these are used as defaults.
+            raise DataModelImportError([error]) from None
+        return str(default_space), str(default_version)

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

@@ -0,0 +1,804 @@
+import json
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import Any, Literal, TypeVar, cast, overload
+
+from pydantic import BaseModel, TypeAdapter, ValidationError
+
+from cognite.neat._data_model.models.dms import (
+    Constraint,
+    ConstraintAdapter,
+    ContainerPropertyDefinition,
+    ContainerRequest,
+    DataModelRequest,
+    Index,
+    IndexAdapter,
+    NodeReference,
+    RequestSchema,
+    SpaceRequest,
+    UniquenessConstraintDefinition,
+    ViewRequest,
+    ViewRequestProperty,
+    ViewRequestPropertyAdapter,
+)
+from cognite.neat._data_model.models.entities import ParsedEntity, parse_entity
+from cognite.neat._exceptions import DataModelImportError
+from cognite.neat._issues import ModelSyntaxError
+from cognite.neat._utils.text import humanize_collection
+from cognite.neat._utils.validation import humanize_validation_error
+
+from .data_classes import DMSContainer, DMSEnum, DMSNode, DMSProperty, DMSView, TableDMS
+from .source import TableSource
+
+T_BaseModel = TypeVar("T_BaseModel", bound=BaseModel)
+
+
+@dataclass
+class ReadViewProperty:
+    prop_id: str
+    row_no: int
+    view_property: ViewRequestProperty
+
+
+@dataclass
+class ReadContainerProperty:
+    prop_id: str
+    row_no: int
+    container_property: ContainerPropertyDefinition
+
+
+@dataclass
+class ReadIndex:
+    prop_id: str
+    order: int | None
+    row_no: int
+    index_id: str
+    index: Index
+
+
+@dataclass
+class ReadConstraint:
+    prop_id: str
+    order: int | None
+    row_no: int
+    constraint_id: str
+    constraint: Constraint
+
+
+@dataclass
+class ReadProperties:
+    """Read properties from the properties table.
+
+    Attributes:
+        container: A mapping from container entity to a mapping of property identifier to container property definition.
+        view: A mapping from view entity to a mapping of property identifier to view property definition.
+        indices: A mapping from (container entity, index identifier) to a list of read indices
+        constraints: A mapping from (container entity, constraint identifier) to a list of read constraints
+    """
+
+    container: dict[tuple[ParsedEntity, str], list[ReadContainerProperty]] = field(
+        default_factory=lambda: defaultdict(list)
+    )
+    view: dict[tuple[ParsedEntity, str], list[ReadViewProperty]] = field(default_factory=lambda: defaultdict(list))
+    indices: dict[tuple[ParsedEntity, str], list[ReadIndex]] = field(default_factory=lambda: defaultdict(list))
+    constraints: dict[tuple[ParsedEntity, str], list[ReadConstraint]] = field(default_factory=lambda: defaultdict(list))
+
+
+@dataclass
+class ProcessedProperties:
+    container: dict[ParsedEntity, dict[str, ContainerPropertyDefinition]] = field(
+        default_factory=lambda: defaultdict(dict)
+    )
+    view: dict[ParsedEntity, dict[str, ViewRequestProperty]] = field(default_factory=lambda: defaultdict(dict))
+    indices: dict[ParsedEntity, dict[str, Index]] = field(default_factory=lambda: defaultdict(dict))
+    constraints: dict[ParsedEntity, dict[str, Constraint]] = field(default_factory=lambda: defaultdict(dict))
+
+
+class DMSTableReader:
+    """Reads a TableDMS object and converts it to a RequestSchema.
+
+
+    Args:
+        default_space (str): The default space to use when no space is given in an entity.
+        default_version (str): The default version to use when no version is given in an entity.
+        source (TableSource): The source of the table data, used for error reporting.
+
+    Raises:
+        DataModelImportError: If there are any errors in the data model.
+
+    Attributes:
+        errors (list[ModelSyntaxError]): A list of errors encountered during parsing.
+
+    Class Attributes:
+        Sheets: This is used to create error messages. It ensures that the column names matches
+            the names in the table, even if they are renamed in the code.
+        PropertyColumns: This is used to create error messages for the properties table.
+            It ensures that the column names matches the names in the table, even if they are renamed in the code.
+        ContainerColumns: This is used to create error messages for the containers table.
+            It ensures that the column names matches the names in the table, even if they are renamed in the code.
+        ViewColumns: This is used to create error messages for the views table.
+            It ensures that the column names matches the names in the table, even if they are renamed in the code.
+
+    """
+
+    # The following classes are used when creating error messages. They ensure that the column names
+    # matches the names in the table, even if they are renamed in the code.
+    # Note that this is not a complete list of all columns, only those that are used in error messages.
+    class Sheets:
+        metadata = cast(str, TableDMS.model_fields["metadata"].validation_alias)
+        properties = cast(str, TableDMS.model_fields["properties"].validation_alias)
+        containers = cast(str, TableDMS.model_fields["containers"].validation_alias)
+        views = cast(str, TableDMS.model_fields["views"].validation_alias)
+        nodes = cast(str, TableDMS.model_fields["nodes"].validation_alias)
+
+    class PropertyColumns:
+        view = cast(str, DMSProperty.model_fields["view"].validation_alias)
+        view_property = cast(str, DMSProperty.model_fields["view_property"].validation_alias)
+        connection = cast(str, DMSProperty.model_fields["connection"].validation_alias)
+        value_type = cast(str, DMSProperty.model_fields["value_type"].validation_alias)
+        min_count = cast(str, DMSProperty.model_fields["min_count"].validation_alias)
+        max_count = cast(str, DMSProperty.model_fields["max_count"].validation_alias)
+        default = cast(str, DMSProperty.model_fields["default"].validation_alias)
+        auto_increment = cast(str, DMSProperty.model_fields["auto_increment"].validation_alias)
+        container = cast(str, DMSProperty.model_fields["container"].validation_alias)
+        container_property = cast(str, DMSProperty.model_fields["container_property"].validation_alias)
+        container_property_name = cast(str, DMSProperty.model_fields["container_property_name"].validation_alias)
+        container_property_description = cast(
+            str, DMSProperty.model_fields["container_property_description"].validation_alias
+        )
+        index = cast(str, DMSProperty.model_fields["index"].validation_alias)
+        constraint = cast(str, DMSProperty.model_fields["constraint"].validation_alias)
+
+    class ContainerColumns:
+        container = cast(str, DMSContainer.model_fields["container"].validation_alias)
+
+    class ViewColumns:
+        view = cast(str, DMSView.model_fields["view"].validation_alias)
+        filter = cast(str, DMSView.model_fields["filter"].validation_alias)
+
+    def __init__(self, default_space: str, default_version: str, source: TableSource) -> None:
+        self.default_space = default_space
+        self.default_version = default_version
+        self.source = source
+        self.errors: list[ModelSyntaxError] = []
+
+    def read_tables(self, tables: TableDMS) -> RequestSchema:
+        space_request = self.read_space(self.default_space)
+        node_types = self.read_nodes(tables.nodes)
+        enum_collections = self.read_enum_collections(tables.enum)
+        read = self.read_properties(tables.properties, enum_collections)
+        processed = self.process_properties(read)
+        containers = self.read_containers(tables.containers, processed)
+        views, valid_view_entities = self.read_views(tables.views, processed.view)
+        data_model = self.read_data_model(tables, valid_view_entities)
+
+        if self.errors:
+            raise DataModelImportError(self.errors) from None
+        return RequestSchema(
+            dataModel=data_model, views=views, containers=containers, spaces=[space_request], nodeTypes=node_types
+        )
+
+    def read_space(self, space: str) -> SpaceRequest:
+        space_request = self._validate_obj(SpaceRequest, {"space": space}, (self.Sheets.metadata,), field_name="value")
+        if space_request is None:
+            # If space is invalid, we stop parsing to avoid raising an error for every place the space is used.
+            raise DataModelImportError(self.errors) from None
+        return space_request
+
+    def read_nodes(self, nodes: list[DMSNode]) -> list[NodeReference]:
+        node_refs: list[NodeReference] = []
+        for row_no, row in enumerate(nodes):
+            data = self._create_node_ref(row.node)
+            instantiated = self._validate_obj(NodeReference, data, (self.Sheets.nodes, row_no))
+            if instantiated is not None:
+                node_refs.append(instantiated)
+        return node_refs
+
+    @staticmethod
+    def read_enum_collections(enum_rows: list[DMSEnum]) -> dict[str, dict[str, Any]]:
+        enum_collections: dict[str, dict[str, Any]] = defaultdict(dict)
+        for row in enum_rows:
+            enum_collections[row.collection][row.value] = {
+                "name": row.name,
+                "description": row.description,
+            }
+        return enum_collections
+
+    def read_properties(
+        self, properties: list[DMSProperty], enum_collections: dict[str, dict[str, Any]]
+    ) -> ReadProperties:
+        read = ReadProperties()
+        for row_no, prop in enumerate(properties):
+            self._process_view_property(prop, read, row_no)
+            if prop.container is None or prop.container_property is None:
+                # This is when the property is an edge or reverse direct relation property.
+                continue
+            self._process_container_property(prop, read, enum_collections, row_no)
+            self._process_index(prop, read, row_no)
+            self._process_constraint(prop, read, row_no)
+        return read
+
+    def process_properties(self, read: ReadProperties) -> ProcessedProperties:
+        return ProcessedProperties(
+            container=self.create_container_properties(read),
+            view=self.create_view_properties(read),
+            indices=self.create_indices(read),
+            constraints=self.create_constraints(read),
+        )
+
+    def create_container_properties(
+        self, read: ReadProperties
+    ) -> dict[ParsedEntity, dict[str, ContainerPropertyDefinition]]:
+        container_props: dict[ParsedEntity, dict[str, ContainerPropertyDefinition]] = defaultdict(dict)
+        for (container_entity, prop_id), prop_list in read.container.items():
+            if len(prop_list) == 0:
+                # Should not happen
+                continue
+            container_props[container_entity][prop_id] = prop_list[0].container_property
+            if len(prop_list) > 1 and self._are_definitions_different(prop_list):
+                # If multiple view properties are mapping to the same container property,
+                # the container property definitions must be the same.
+                rows_str = humanize_collection(
+                    [self.source.adjust_row_number(self.Sheets.properties, p.row_no) for p in prop_list]
+                )
+                container_columns_str = humanize_collection(
+                    [
+                        self.PropertyColumns.connection,
+                        self.PropertyColumns.value_type,
+                        self.PropertyColumns.min_count,
+                        self.PropertyColumns.max_count,
+                        self.PropertyColumns.default,
+                        self.PropertyColumns.auto_increment,
+                        self.PropertyColumns.container_property_name,
+                        self.PropertyColumns.container_property_description,
+                        self.PropertyColumns.index,
+                        self.PropertyColumns.constraint,
+                    ]
+                )
+                self.errors.append(
+                    ModelSyntaxError(
+                        message=(
+                            f"In {self.source.location((self.Sheets.properties,))} "
+                            f"when the column {self.PropertyColumns.container!r} and "
+                            f"{self.PropertyColumns.container_property!r} are the same, "
+                            f"all the container columns ({container_columns_str}) must be the same. "
+                            f"Inconsistent definitions for container '{container_entity!s} "
+                            f"and {prop_id!r}' found in rows {rows_str}."
+                        )
+                    )
+                )
+        return container_props
+
+    def _are_definitions_different(self, prop_list: list[ReadContainerProperty]) -> bool:
+        if len(prop_list) < 2:
+            return False
+        first_def = prop_list[0].container_property
+        for prop in prop_list[1:]:
+            if first_def != prop.container_property:
+                return True
+        return False
+
+    def create_view_properties(self, read: ReadProperties) -> dict[ParsedEntity, dict[str, ViewRequestProperty]]:
+        view_props: dict[ParsedEntity, dict[str, ViewRequestProperty]] = defaultdict(dict)
+        for (view_entity, prop_id), prop_list in read.view.items():
+            if len(prop_list) == 0:
+                # Should not happen
+                continue
+            view_props[view_entity][prop_id] = prop_list[0].view_property
+            if len(prop_list) > 1:
+                # Safeguard against duplicated rows for view properties.
+                rows_str = humanize_collection(
+                    [self.source.adjust_row_number(self.Sheets.properties, p.row_no) for p in prop_list]
+                )
+                self.errors.append(
+                    ModelSyntaxError(
+                        message=(
+                            f"In {self.source.location((self.Sheets.properties,))} the combination of columns "
+                            f"{self.PropertyColumns.view!r} and {self.PropertyColumns.view_property!r} must be unique. "
+                            f"Duplicated entries for view '{view_entity!s}' and "
+                            f"property '{prop_id!s}' found in rows {rows_str}."
+                        )
+                    )
+                )
+
+        return view_props
+
+    def create_indices(self, read: ReadProperties) -> dict[ParsedEntity, dict[str, Index]]:
+        indices: dict[ParsedEntity, dict[str, Index]] = defaultdict(dict)
+        for (container_entity, index_id), index_list in read.indices.items():
+            if len(index_list) == 0:
+                continue
+            index = index_list[0].index
+            if len(index_list) == 1:
+                indices[container_entity][index_id] = index
+                continue
+            if missing_order := [idx for idx in index_list if idx.order is None]:
+                row_str = humanize_collection(
+                    [self.source.adjust_row_number(self.Sheets.properties, idx.row_no) for idx in missing_order]
+                )
+                self.errors.append(
+                    ModelSyntaxError(
+                        message=(
+                            f"In table {self.Sheets.properties!r} column {self.PropertyColumns.index!r}: "
+                            f"the index {index_id!r} on container {container_entity!s} is defined on multiple "
+                            f"properties. This requires the 'order' attribute to be set. It is missing in rows "
+                            f"{row_str}."
+                        )
+                    )
+                )
+                continue
+            index.properties = [idx.prop_id for idx in sorted(index_list, key=lambda x: x.order or 999)]
+            indices[container_entity][index_id] = index
+        return indices
+
+    def create_constraints(self, read: ReadProperties) -> dict[ParsedEntity, dict[str, Constraint]]:
+        constraints: dict[ParsedEntity, dict[str, Constraint]] = defaultdict(dict)
+        for (container_entity, constraint_id), constraint_list in read.constraints.items():
+            if len(constraint_list) == 0:
+                continue
+            constraint = constraint_list[0].constraint
+            if len(constraint_list) == 1 or not isinstance(constraint, UniquenessConstraintDefinition):
+                constraints[container_entity][constraint_id] = constraint
+                continue
+            if missing_order := [c for c in constraint_list if c.order is None]:
+                row_str = humanize_collection(
+                    [self.source.adjust_row_number(self.Sheets.properties, c.row_no) for c in missing_order]
+                )
+                self.errors.append(
+                    ModelSyntaxError(
+                        message=(
+                            f"In table {self.Sheets.properties!r} column {self.PropertyColumns.constraint!r}: "
+                            f"the uniqueness constraint {constraint_id!r} on container {container_entity!s} is defined "
+                            f"on multiple properties. This requires the 'order' attribute to be set. It is missing in "
+                            f"rows {row_str}."
+                        )
+                    )
+                )
+                continue
+            constraint.properties = [c.prop_id for c in sorted(constraint_list, key=lambda x: x.order or 999)]
+            constraints[container_entity][constraint_id] = constraint
+        return constraints
+
+    def _process_view_property(self, prop: DMSProperty, read: ReadProperties, row_no: int) -> None:
+        loc = (self.Sheets.properties, row_no)
+        data = self.read_view_property(prop, loc)
+        view_prop = self._validate_adapter(ViewRequestPropertyAdapter, data, loc)
+        if view_prop is not None:
+            read.view[(prop.view, prop.view_property)].append(
+                # MyPy has a very strange complaint here. It complains that given type is not expected type,
+                # even though they are exactly the same.
+                ReadViewProperty(prop.container_property, row_no, view_prop)  # type: ignore[arg-type]
+            )
+        return None
+
+    def _process_container_property(
+        self, prop: DMSProperty, read: ReadProperties, enum_collections: dict[str, dict[str, Any]], row_no: int
+    ) -> None:
+        loc = (self.Sheets.properties, row_no)
+        data = self.read_container_property(prop, enum_collections, loc=loc)
+        container_prop = self._validate_obj(ContainerPropertyDefinition, data, loc)
+        if container_prop is not None and prop.container and prop.container_property:
+            read.container[(prop.container, prop.container_property)].append(
+                ReadContainerProperty(prop.container_property, row_no, container_prop)
+            )
+        return None
+
+    def _process_index(self, prop: DMSProperty, read: ReadProperties, row_no: int) -> None:
+        if prop.index is None or prop.container_property is None or prop.container is None:
+            return
+
+        loc = (self.Sheets.properties, row_no, self.PropertyColumns.index)
+        for index in prop.index:
+            data = self.read_index(index, prop.container_property)
+            created = self._validate_adapter(IndexAdapter, data, loc)
+            if created is None:
+                continue
+            order = self._read_order(index.properties, loc)
+            read.indices[(prop.container, index.suffix)].append(
+                ReadIndex(
+                    prop_id=prop.container_property, order=order, row_no=row_no, index_id=index.suffix, index=created
+                )
+            )
+
+    def _read_order(self, properties: dict[str, Any], loc: tuple[str | int, ...]) -> int | None:
+        if "order" not in properties:
+            return None
+        try:
+            return int(properties["order"])
+        except ValueError:
+            self.errors.append(
+                ModelSyntaxError(
+                    message=f"In {self.source.location(loc)} invalid order value '{properties['order']}'. "
+                    "Must be an integer."
+                )
+            )
+            return None
+
+    @staticmethod
+    def read_index(index: ParsedEntity, prop_id: str) -> dict[str, Any]:
+        return {
+            "indexType": index.prefix,
+            "properties": [prop_id],
+            **index.properties,
+        }
+
+    def _process_constraint(self, prop: DMSProperty, read: ReadProperties, row_no: int) -> None:
+        if prop.constraint is None or prop.container_property is None or prop.container is None:
+            return
+        loc = (self.Sheets.properties, row_no, self.PropertyColumns.constraint)
+        for constraint in prop.constraint:
+            data = self.read_constraint(constraint, prop.container_property)
+            created = self._validate_adapter(ConstraintAdapter, data, loc)
+            if created is None:
+                continue
+            order = self._read_order(constraint.properties, loc)
+            read.constraints[(prop.container, constraint.suffix)].append(
+                ReadConstraint(
+                    prop_id=prop.container_property,
+                    order=order,
+                    constraint_id=constraint.suffix,
+                    row_no=row_no,
+                    constraint=created,
+                )
+            )
+
+    @staticmethod
+    def read_constraint(constraint: ParsedEntity, prop_id: str) -> dict[str, Any]:
+        return {"constraintType": constraint.prefix, "properties": [prop_id], **constraint.properties}
+
+    def read_view_property(self, prop: DMSProperty, loc: tuple[str | int, ...]) -> dict[str, Any]:
+        """Reads a single view property from a given row in the properties table.
+
+        The type of property (core, edge, reverse direct relation) is determined based on the connection column
+        as follows:
+        1. If the connection is empty or 'direct' it is a core property.
+        2. If the connection is 'edge' it is an edge property.
+        3. If the connection is 'reverse' it is a reverse direct relation property
+        4. Otherwise, it is an error.
+
+        Args:
+            prop (DMSProperty): The property row to read.
+            loc (tuple[str | int, ...]): The location of the property in the source for error reporting.
+
+        Returns:
+            ViewRequestProperty: The parsed view property.
+        """
+
+        if prop.connection is None or prop.connection.suffix == "direct":
+            return self.read_core_view_property(prop)
+        elif prop.connection.suffix == "edge":
+            return self.read_edge_view_property(prop, loc)
+        elif prop.connection.suffix == "reverse":
+            return self.read_reverse_direct_relation_view_property(prop)
+        else:
+            self.errors.append(
+                ModelSyntaxError(
+                    message=f"In {self.source.location(loc)} invalid connection type '{prop.connection.suffix}'. "
+                )
+            )
+            return {}
+
+    def read_core_view_property(self, prop: DMSProperty) -> dict[str, Any]:
+        return dict(
+            connectionType="primary_property",
+            name=prop.name,
+            description=prop.description,
+            container=self._create_container_ref(prop.container),
+            containerPropertyIdentifier=prop.container_property,
+            source=None if prop.connection is None else self._create_view_ref(prop.value_type),
+        )
+
+    def read_edge_view_property(self, prop: DMSProperty, loc: tuple[str | int, ...]) -> dict[str, Any]:
+        if prop.connection is None:
+            return {}
+        edge_source: dict[str, str | None] | None = None
+        if "edgeSource" in prop.connection.properties:
+            edge_source = self._create_view_ref_unparsed(
+                prop.connection.properties["edgeSource"], (*loc, self.PropertyColumns.connection, "edgeSource")
+            )
+        return dict(
+            connectionType="single_edge_connection" if prop.max_count == 1 else "multi_edge_connection",
+            name=prop.name,
+            description=prop.description,
+            source=self._create_view_ref(prop.value_type),
+            type=self._create_node_ref_unparsed(
+                prop.connection.properties.get("type"),
+                prop.view,
+                prop.view_property,
+                (*loc, self.PropertyColumns.connection, "type"),
+            ),
+            edgeSource=edge_source,
+            direction=prop.connection.properties.get("direction", "outwards"),
+        )
+
+    def read_reverse_direct_relation_view_property(
+        self,
+        prop: DMSProperty,
+    ) -> dict[str, Any]:
+        if prop.connection is None:
+            return {}
+        view_ref = self._create_view_ref(prop.value_type)
+        return dict(
+            connectionType="single_reverse_direct_relation" if prop.max_count == 1 else "multi_reverse_direct_relation",
+            name=prop.name,
+            description=prop.description,
+            source=view_ref,
+            through={
+                "source": view_ref,
+                "identifier": prop.connection.properties.get("property"),
+            },
+        )
+
+    def read_container_property(
+        self, prop: DMSProperty, enum_collections: dict[str, dict[str, Any]], loc: tuple[str | int, ...]
+    ) -> dict[str, Any]:
+        data_type = self._read_data_type(prop, enum_collections, loc)
+        return dict(
+            immutable=prop.immutable,
+            nullable=prop.min_count == 0 or prop.min_count is None,
+            autoIncrement=prop.auto_increment,
+            defaultValue=prop.default,
+            description=prop.container_property_description,
+            name=prop.container_property_name,
+            type=data_type,
+        )
+
+    def _read_data_type(
+        self, prop: DMSProperty, enum_collections: dict[str, dict[str, Any]], loc: tuple[str | int, ...]
+    ) -> dict[str, Any]:
+        # Implementation to read the container property type from DMSProperty
+        is_list = None if prop.max_count is None else prop.max_count > 1
+        max_list_size: int | None = None
+        if is_list and prop.max_count is not None:
+            max_list_size = prop.max_count
+
+        args: dict[str, Any] = {
+            "maxListSize": max_list_size,
+            "list": is_list,
+            "type": "direct" if prop.connection is not None else prop.value_type.suffix,
+        }
+        args.update(prop.value_type.properties)
+        if "container" in args and prop.connection is not None:
+            # Direct relation constraint.
+            args["container"] = self._create_container_ref_unparsed(
+                prop.connection.properties["container"], (*loc, self.PropertyColumns.connection, "container")
+            )
+        if args["type"] == "enum" and "collection" in prop.value_type.properties:
+            args["values"] = enum_collections.get(prop.value_type.properties["collection"], {})
+        return args
+
+    def read_containers(
+        self, containers: list[DMSContainer], properties: ProcessedProperties
+    ) -> list[ContainerRequest]:
+        # Implementation to read containers from DMSContainer list
+        containers_requests: list[ContainerRequest] = []
+        rows_by_seen: dict[ParsedEntity, list[int]] = defaultdict(list)
+        for row_no, container in enumerate(containers):
+            container_request = self._validate_obj(
+                ContainerRequest,
+                dict(
+                    **self._create_container_ref(container.container),
+                    usedFor=container.used_for,
+                    name=container.name,
+                    description=container.description,
+                    properties=properties.container[container.container],
+                    indexes=properties.indices.get(container.container),
+                    constraints=properties.constraints.get(container.container),
+                ),
+                (self.Sheets.containers, row_no),
+            )
+            if container_request is None:
+                continue
+            if container.container in rows_by_seen:
+                rows_by_seen[container.container].append(row_no)
+            else:
+                containers_requests.append(container_request)
+                rows_by_seen[container.container] = [row_no]
+        for entity, rows in rows_by_seen.items():
+            if len(rows) > 1:
+                rows_str = humanize_collection([self.source.adjust_row_number(self.Sheets.containers, r) for r in rows])
+                self.errors.append(
+                    ModelSyntaxError(
+                        message=(
+                            f"In {self.source.location((self.Sheets.containers,))} the values in "
+                            f"column {self.ContainerColumns.container!r} must be unique. "
+                            f"Duplicated entries for container '{entity!s}' found in rows {rows_str}."
+                        )
+                    )
+                )
+        return containers_requests
+
+    def read_views(
+        self,
+        views: list[DMSView],
+        properties: dict[ParsedEntity, dict[str, ViewRequestProperty]],
+    ) -> tuple[list[ViewRequest], set[ParsedEntity]]:
+        views_requests: list[ViewRequest] = []
+        rows_by_seen: dict[ParsedEntity, list[int]] = defaultdict(list)
+        for row_no, view in enumerate(views):
+            filter_dict: dict[str, Any] | None = None
+            if view.filter is not None:
+                try:
+                    filter_dict = json.loads(view.filter)
+                except ValueError as e:
+                    self.errors.append(
+                        ModelSyntaxError(
+                            message=(
+                                f"In {self.source.location((self.Sheets.views, row_no, self.ViewColumns.filter))} "
+                                f"must be valid json. Got error {e!s}"
+                            )
+                        )
+                    )
+            view_request = self._validate_obj(
+                ViewRequest,
+                dict(
+                    **self._create_view_ref(view.view),
+                    name=view.name,
+                    description=view.description,
+                    implements=[self._create_view_ref(impl) for impl in view.implements] if view.implements else None,
+                    filter=filter_dict,
+                    properties=properties.get(view.view, {}),
+                ),
+                (self.Sheets.views, row_no),
+            )
+            if view_request is None:
+                continue
+            if view.view in rows_by_seen:
+                rows_by_seen[view.view].append(row_no)
+            else:
+                views_requests.append(view_request)
+                rows_by_seen[view.view] = [row_no]
+        for entity, rows in rows_by_seen.items():
+            if len(rows) > 1:
+                rows_str = humanize_collection([self.source.adjust_row_number(self.Sheets.views, r) for r in rows])
+                self.errors.append(
+                    ModelSyntaxError(
+                        message=(
+                            f"In {self.source.location((self.Sheets.views,))} the values in "
+                            f"column {self.ViewColumns.view!r} must be unique. "
+                            f"Duplicated entries for view '{entity!s}' found in rows {rows_str}."
+                        )
+                    )
+                )
+        return views_requests, set(rows_by_seen.keys())
+
+    def read_data_model(self, tables: TableDMS, valid_view_entities: set[ParsedEntity]) -> DataModelRequest:
+        data = {
+            **{meta.key: meta.value for meta in tables.metadata},
+            "views": [
+                self._create_view_ref(view.view)
+                for view in tables.views
+                if view.in_model is not False and view.view in valid_view_entities
+            ],
+        }
+        model = self._validate_obj(DataModelRequest, data, (self.Sheets.metadata,), field_name="value")
+        if model is None:
+            # This is the last step, so we can raise the error here.
+            raise DataModelImportError(self.errors) from None
+        return model
+
+    def _parse_entity(self, entity: str, loc: tuple[str | int, ...]) -> ParsedEntity | None:
+        try:
+            parsed = parse_entity(entity)
+        except ValueError as e:
+            self.errors.append(
+                ModelSyntaxError(message=f"In {self.source.location(loc)} failed to parse entity '{entity}': {e!s}")
+            )
+            return None
+        return parsed
+
+    def _create_view_ref_unparsed(self, entity: str, loc: tuple[str | int, ...]) -> dict[str, str | None]:
+        parsed = self._parse_entity(entity, loc)
+        if parsed is None:
+            return dict()
+        return self._create_view_ref(parsed)
+
+    def _create_view_ref(self, entity: ParsedEntity | None) -> dict[str, str | None]:
+        if entity is None or entity.suffix == "":
+            # If no suffix is given, we cannot create a valid reference.
+            return dict()
+        space, version = entity.prefix, entity.properties.get("version")
+        if space == "":
+            space = self.default_space
+            # Only if default space is used, we can use default version.
+            if version is None:
+                version = self.default_version
+        return {
+            "space": space,
+            "externalId": entity.suffix,
+            "version": version,
+        }
+
+    def _create_container_ref_unparsed(self, entity: str, loc: tuple[str | int, ...]) -> dict[str, str]:
+        parsed = self._parse_entity(entity, loc)
+        if parsed is None:
+            return dict()
+        return self._create_container_ref(parsed)
+
+    def _create_container_ref(self, entity: ParsedEntity | None) -> dict[str, str]:
+        if entity is None or entity.suffix == "":
+            # If no suffix is given, we cannot create a valid reference.
+            return dict()
+        return {
+            "space": entity.prefix or self.default_space,
+            "externalId": entity.suffix,
+        }
+
+    def _create_node_ref_unparsed(
+        self, entity: str | None, view: ParsedEntity, view_prop: str, loc: tuple[str | int, ...]
+    ) -> dict[str, str | None]:
+        if entity is None:
+            # Use default
+            return self._create_node_ref(None, view, view_prop)
+        parsed = self._parse_entity(entity, loc)
+        if parsed is None:
+            return dict()
+        return self._create_node_ref(parsed, view, view_prop)
+
+    @overload
+    def _create_node_ref(
+        self, entity: ParsedEntity, *, view: None = None, view_prop: None = None
+    ) -> dict[str, str | None]: ...
+
+    @overload
+    def _create_node_ref(
+        self, entity: ParsedEntity | None, view: ParsedEntity, view_prop: str
+    ) -> dict[str, str | None]: ...
+
+    def _create_node_ref(
+        self, entity: ParsedEntity | None, view: ParsedEntity | None = None, view_prop: str | None = None
+    ) -> dict[str, str | None]:
+        if entity is None or entity.suffix == "":
+            if view is None or view_prop is None:
+                return dict()
+            # If no suffix is given, we fallback to the view's property
+            return {
+                "space": view.prefix or self.default_space,
+                "externalId": f"{view.suffix}.{view_prop}",
+            }
+        return {
+            "space": entity.prefix or self.default_space,
+            "externalId": entity.suffix,
+        }
+
+    def _validate_obj(
+        self,
+        obj: type[T_BaseModel],
+        data: dict,
+        parent_loc: tuple[str | int, ...],
+        field_name: Literal["field", "column", "value"] = "column",
+    ) -> T_BaseModel | None:
+        try:
+            return obj.model_validate(data)
+        except ValidationError as e:
+            self._add_error_messages(e, parent_loc, field_name=field_name)
+            return None
+
+    def _validate_adapter(
+        self, adapter: TypeAdapter[T_BaseModel], data: dict[str, Any], parent_loc: tuple[str | int, ...]
+    ) -> T_BaseModel | None:
+        try:
+            return adapter.validate_python(data, strict=True)
+        except ValidationError as e:
+            self._add_error_messages(e, parent_loc, field_name="column")
+            return None
+
+    def _add_error_messages(
+        self,
+        error: ValidationError,
+        parent_loc: tuple[str | int, ...],
+        field_name: Literal["field", "column", "value"] = "column",
+    ) -> None:
+        seen: set[str] = set()
+        for message in humanize_validation_error(
+            error,
+            parent_loc=parent_loc,
+            humanize_location=self.source.location,
+            field_name=field_name,
+            field_renaming=self.source.field_mapping(parent_loc[0]),
+            missing_required_descriptor="empty" if field_name == "column" else "missing",
+        ):
+            if message in seen:
+                continue
+            seen.add(message)
+            self.errors.append(ModelSyntaxError(message=message))

cognite/neat/_data_model/models/dms/__init__.py

@@ -60,6 +60,7 @@ from ._view_property import (
     ViewCorePropertyResponse,
     ViewPropertyDefinition,
     ViewRequestProperty,
+    ViewRequestPropertyAdapter,
     ViewResponseProperty,
 )
 from ._views import (
@@ -135,6 +136,7 @@ __all__ = [
     "ViewReference",
     "ViewRequest",
     "ViewRequestProperty",
+    "ViewRequestPropertyAdapter",
     "ViewResponse",
     "ViewResponseProperty",
     "WriteableResource",

cognite/neat/_utils/useful_types.py

@@ -9,3 +9,6 @@ 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
+
+# The format expected for excel sheets representing a data model
+DataModelTableType: TypeAlias = dict[str, list[dict[str, CellValueType]]]

cognite/neat/_version.py

@@ -1,2 +1,2 @@
-__version__ = "0.125.0"
+__version__ = "0.126.0"
 __engine__ = "^2.0.4"

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

@@ -377,7 +377,7 @@ def _replace_legacy_constraint_form(sheet: Worksheet) -> None:
                 constraints = []
                 for constraint in SPLIT_ON_COMMA_PATTERN.split(str(cell.value)):
                     # latest format, do nothing
-                    if "container" in constraint.lower():
+                    if "require" in constraint.lower():
                         constraints.append(constraint)
                         continue
 
@@ -385,7 +385,7 @@ def _replace_legacy_constraint_form(sheet: Worksheet) -> None:
                         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})"
+                            f"requires:{container.space}_{container.external_id}(require={container_str})"
                         )
                         replaced = True
                     except ValidationError:

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

@@ -666,7 +666,7 @@ 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
+    require: ContainerEntity | None = None
 
     def as_id(self) -> None:
         return None

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

@@ -285,7 +285,7 @@ class UnverifiedPhysicalContainer(UnverifiedComponent[PhysicalContainer]):
         for constraint_name, constraint_obj in (container.constraints or {}).items():
             if isinstance(constraint_obj, dm.RequiresConstraint):
                 constraint = ContainerConstraintEntity(
-                    prefix="requires", suffix=constraint_name, container=ContainerEntity.from_id(constraint_obj.require)
+                    prefix="requires", suffix=constraint_name, require=ContainerEntity.from_id(constraint_obj.require)
                 )
                 constraints.append(str(constraint))
 

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

@@ -123,8 +123,8 @@ class PhysicalValidation:
 
         for container in self._containers or []:
             for constraint in container.constraint or []:
-                if constraint.container not in existing_containers:
-                    imported_containers.add(cast(ContainerEntity, constraint.container))
+                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

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

@@ -419,7 +419,7 @@ class PhysicalContainer(SheetRow):
                 message = f"Constraint id '{constraint.suffix}' exceeds maximum length of {CONSTRAINT_ID_MAX_LENGTH}."
                 raise ValueError(message) from None
 
-            if constraint.container is None:
+            if constraint.require is None:
                 message = (
                     f"Container constraint must have a container set. "
                     f"Please set 'requires:{constraint!s}(container=space:external_id)'."
@@ -435,9 +435,9 @@ class PhysicalContainer(SheetRow):
         container_id = self.container.as_id()
         constraints: dict[str, dm.Constraint] = {}
         for constraint in self.constraint or []:
-            if constraint.container is None:
+            if constraint.require is None:
                 continue
-            requires = dm.RequiresConstraint(constraint.container.as_id())
+            requires = dm.RequiresConstraint(constraint.require.as_id())
             constraints[constraint.suffix] = requires
 
         return dm.ContainerApply(

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

@@ -1650,7 +1650,7 @@ class _ConceptualDataModelConverter:
                         ContainerConstraintEntity(
                             prefix="requires",
                             suffix=f"{parent_entity.space}_{parent_entity.external_id}"[:CONSTRAINT_ID_MAX_LENGTH],
-                            container=parent_entity,
+                            require=parent_entity,
                         )
                     )
         return constrains

cognite/neat/v0/core/_instances/queries/_select.py

@@ -451,9 +451,21 @@ class SelectQueries(BaseQuery):
             else:
                 yield instance_id, str(space)
 
-    def _get_graph_diff(
+    def get_graph_diff(
         self, source_graph: URIRef, target_graph: URIRef
     ) -> Iterable[tuple[URIRef, URIRef, URIRef | RdfLiteral]]:
+        """Return triples that exist in the source graph but not in the target graph.
+
+        This method compares two named graphs within the dataset and identifies all triples
+        that are present in the `source_graph` but are missing from the `target_graph`.
+
+        Args:
+            source_graph: URI of the graph to compare from.
+            target_graph: URI of the graph to compare against.
+
+        Returns:
+            Iterable of triples (subject, predicate, object)
+        """
         query = f"""
         SELECT ?s ?p ?o
         WHERE {{
@@ -464,31 +476,3 @@ class SelectQueries(BaseQuery):
         }}
         """
         return cast(Iterable[tuple[URIRef, URIRef, URIRef | RdfLiteral]], self.dataset.query(query))
-
-    def get_triples_to_delete(
-        self, old_graph: URIRef, new_graph: URIRef
-    ) -> Iterable[tuple[URIRef, URIRef, URIRef | RdfLiteral]]:
-        """Find triples that exist in old graph but not in new graph.
-
-        Args:
-            old_graph: URI of the old named graph
-            new_graph: URI of the new named graph
-
-        Returns:
-            List of triples (subject, predicate, object) to delete
-        """
-        return self._get_graph_diff(old_graph, new_graph)
-
-    def get_triples_to_add(
-        self, old_graph: URIRef, new_graph: URIRef
-    ) -> Iterable[tuple[URIRef, URIRef, URIRef | RdfLiteral]]:
-        """Find triples that exist in new graph but not in old graph.
-
-        Args:
-            old_graph: URI of the old named graph
-            new_graph: URI of the new named graph
-
-        Returns:
-            List of triples (subject, predicate, object) to add
-        """
-        return self._get_graph_diff(new_graph, old_graph)

cognite/neat/v0/core/_store/_instance.py

@@ -476,10 +476,10 @@ class NeatInstanceStore:
 
         # Store new diff results
         self._add_triples(
-            self.queries.select.get_triples_to_add(current_named_graph, new_named_graph),
+            self.queries.select.get_graph_diff(new_named_graph, current_named_graph),
             named_graph=NAMED_GRAPH_NAMESPACE["DIFF_ADD"],
         )
         self._add_triples(
-            self.queries.select.get_triples_to_delete(current_named_graph, new_named_graph),
+            self.queries.select.get_graph_diff(current_named_graph, new_named_graph),
             named_graph=NAMED_GRAPH_NAMESPACE["DIFF_DELETE"],
         )

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

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

@@ -1,16 +1,20 @@
 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=uGBcX4xuE__guAX0yJVFt4XCMymM1MTnVvYJi0BG7QM,46
+cognite/neat/_version.py,sha256=kvjU7yRcXW905fNDDrk9Rmv1eMH9zdS38_vx_BqoxPA,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/exporters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cognite/neat/_data_model/exporters/_base.py,sha256=sCBa02bW5HU9MHIGcoCHq_xyaQ6jlbtGnk2tor3wmm0,430
+cognite/neat/_data_model/exporters/_table_exporter.py,sha256=_0-GABdkqWKimUByT63H_dXNI2Uxuc1zOvvThP3lpko,1212
 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/importer.py,sha256=pkE7OBe5qQ1Rs0wEk5DEUuttmCp8zKJ0U_Nu9GP0rPk,4559
+cognite/neat/_data_model/importers/_table_importer/reader.py,sha256=U7hDYAk1bQq4xTj3na7n1G9qllp522hWzojXAGQ9FUw,36876
 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
@@ -19,7 +23,7 @@ cognite/neat/_data_model/models/conceptual/_concept.py,sha256=0Pk4W2TJ_Y0Z7oPHpz
 cognite/neat/_data_model/models/conceptual/_data_model.py,sha256=mSX0z8i29ufcRUhvC_NPeo2xGidlK3B1n89kngY_SqQ,1695
 cognite/neat/_data_model/models/conceptual/_properties.py,sha256=CpF37vJYBTLT4DH4ZOu2U-JyWtkb_27V8fw52qiaE_k,4007
 cognite/neat/_data_model/models/conceptual/_property.py,sha256=blSZQxX52zaILAtjUkldPzPeysz7wnG-UGSNU5tacI8,4138
-cognite/neat/_data_model/models/dms/__init__.py,sha256=ZIoXXe6I_0Z-x8K6n4UghzCQbt-KDlzAvXLYVd7dn8w,3829
+cognite/neat/_data_model/models/dms/__init__.py,sha256=du7UBnz1BxvAHFgpHG-aNkZXfz6NXRmuptpCv27LVtk,3895
 cognite/neat/_data_model/models/dms/_base.py,sha256=F49CLKUmtjTaaW0NrQbjqGkpWNgnZMV8m8uomCU_FJU,719
 cognite/neat/_data_model/models/dms/_constants.py,sha256=wBkLjAPwufPc2naxOfPA1XC0CM2RbDbo6Dpiv9dPrew,1344
 cognite/neat/_data_model/models/dms/_constraints.py,sha256=QxcsHzdaYe3E5_xTIdtQDfkLPOzKa2c-0D02QKLto9o,1064
@@ -47,7 +51,7 @@ cognite/neat/_session/_state_machine/_states.py,sha256=RX6C0YNNT9mX0C6c-ZTiUVh6p
 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=tDspKjU4AkzB6P1kKPNaVpx-yvx3V2uQVC3FAr6nibM,1835
-cognite/neat/_utils/useful_types.py,sha256=3qVfeQXg0xCcSEG7RymYU84LDbk0joKzruFY9EKAX8g,415
+cognite/neat/_utils/useful_types.py,sha256=iCpT4vrn95Y4ATmyOI_eHMm7Lb-h1CeO5fVuWOVUgDQ,555
 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
@@ -94,7 +98,7 @@ cognite/neat/v0/core/_data_model/importers/_base_file_reader.py,sha256=OjjXb0IOl
 cognite/neat/v0/core/_data_model/importers/_dict2data_model.py,sha256=CeDZNAO4W5JZmrboYtTfHnuU1UoXRI2nOUaasWmxfqM,4720
 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=qsvb4cA93VpTfMATaVnZyXs-hpzTfxl8jwGk5cpp3k0,15437
+cognite/neat/v0/core/_data_model/importers/_spreadsheet2data_model.py,sha256=ksD_AnFngPNTNOzQdguoV2MNcIJXBVwTkKJKmKOGm7s,15433
 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
@@ -115,7 +119,7 @@ cognite/neat/v0/core/_data_model/models/entities/_constants.py,sha256=GXRzVfArwx
 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=ou6adX0-h7PVN7_6IrvP8WXoCDpstTkq7C9Yh_scaZU,24404
+cognite/neat/v0/core/_data_model/models/entities/_single_value.py,sha256=hoBU7bfTcjnhkn83zW24JAVrargu_j-wy1NqceR18JA,24402
 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
@@ -123,12 +127,12 @@ cognite/neat/v0/core/_data_model/models/mapping/_classic2core.py,sha256=F0zusTh9
 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=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/models/physical/_unverified.py,sha256=eE2D2DPfqEfOnYaUmOTPhBpHp9oN-gxjn8CTe_GKtz0,22419
+cognite/neat/v0/core/_data_model/models/physical/_validation.py,sha256=g0uSZImYaGmMZEwHUpb8KF9LTPiztz7k7cFQT3jrs4Y,41326
+cognite/neat/v0/core/_data_model/models/physical/_verified.py,sha256=49dn3K_gWO3VgfS-SK4kHpbSJywtj4mwES3iy-43z4M,29824
 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=vgypwPCI14DtKDl3WdXzuFxH1bgxH-7yLG-Ytvjo0MM,112042
+cognite/neat/v0/core/_data_model/transformers/_converters.py,sha256=Wmd4Lc62Xu8o_HCp7QVA6EEubEWzjbGQH5MEI88fpFo,112040
 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
@@ -167,7 +171,7 @@ cognite/neat/v0/core/_instances/loaders/_rdf_to_instance_space.py,sha256=T1nNzhY
 cognite/neat/v0/core/_instances/queries/__init__.py,sha256=W477LMyB4l6HIRbQhJoFgA_MUBwVCh2GBvtFeZu0AUA,53
 cognite/neat/v0/core/_instances/queries/_base.py,sha256=APevHeeWQDEoOQ0MlBtVlPf9hbZukVkI5fOvt5oPJCE,543
 cognite/neat/v0/core/_instances/queries/_queries.py,sha256=4BidSQXhdZYZ6_kyG7jMJ2iG0UtSrbQxfmwPM7V167A,466
-cognite/neat/v0/core/_instances/queries/_select.py,sha256=NYEEGafbb02poVb3vJ9Ov0XQq9f8YRxpfqq1WFc-36Q,20539
+cognite/neat/v0/core/_instances/queries/_select.py,sha256=MoMCjRVeOhOPAJ6Tlc91ZSj8ibOIfEV5aoGg4kR1qS0,20068
 cognite/neat/v0/core/_instances/queries/_update.py,sha256=WJmh0hGoKT4pbbWeED6udFAXiv_qFPd3v9tnZLORcNk,1293
 cognite/neat/v0/core/_instances/transformers/__init__.py,sha256=YzC1Z8BuT77NwagWX4Z-F9R9BARLSS7zM4bCdxBbqKg,1761
 cognite/neat/v0/core/_instances/transformers/_base.py,sha256=a8TVhgYGdt7Mj5-omT6gxOHeGvYnMd9vJCty6p7ctx4,4707
@@ -195,7 +199,7 @@ cognite/neat/v0/core/_issues/warnings/_resources.py,sha256=L4iTuVYgfwcaCRTbTCVoo
 cognite/neat/v0/core/_issues/warnings/user_modeling.py,sha256=neM9IJzLGWFcBiuo5p5CLFglXjrUXR61FNqvupNw7Y0,4147
 cognite/neat/v0/core/_store/__init__.py,sha256=wpsF8xjIQ5V21NOh45XQV813n_EzgyPOt0VVinYjnDI,140
 cognite/neat/v0/core/_store/_data_model.py,sha256=09JlHEkJVEPHCju8ixRUUsvRcZb0UrDE7wevB7tq4PI,19682
-cognite/neat/v0/core/_store/_instance.py,sha256=NokBDdPkp1K6Ce53dwx3jsBePgGUX0ggXPCGC5HvnGw,18935
+cognite/neat/v0/core/_store/_instance.py,sha256=zt7pgYwgMbnAwz7Xn-_AiMsXhbBdwXWBRKu2MrgE3jI,18924
 cognite/neat/v0/core/_store/_provenance.py,sha256=Q96wkVXRovO_uTlNvwCAOl6pAoWItTgFq1F79L_FqBk,7335
 cognite/neat/v0/core/_store/exceptions.py,sha256=dTaBSt7IV7XWtS3EsE8lBX1Dv3tfWX1nIEgGHkluy3s,1668
 cognite/neat/v0/core/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -244,7 +248,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.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,,
+cognite_neat-0.126.0.dist-info/METADATA,sha256=bD3aNMQGJUehi3xBg0fVg8pYW6mKPAwN1mXNIBIGiXw,9147
+cognite_neat-0.126.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cognite_neat-0.126.0.dist-info/licenses/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
+cognite_neat-0.126.0.dist-info/RECORD,,