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

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/_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/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.1.dist-info}/METADATA

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