cognite-neat 0.123.43__py3-none-any.whl → 0.125.0__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/_store/_instance.py

@@ -12,6 +12,7 @@ from rdflib import Dataset, Graph, Namespace, URIRef
 from rdflib.graph import DATASET_DEFAULT_GRAPH_ID
 from rdflib.plugins.stores.sparqlstore import SPARQLUpdateStore
 
+from cognite.neat.v0.core._constants import NAMED_GRAPH_NAMESPACE
 from cognite.neat.v0.core._instances._shared import quad_formats, rdflib_to_oxi_type
 from cognite.neat.v0.core._instances.extractors import RdfFileExtractor, TripleExtractors
 from cognite.neat.v0.core._instances.queries import Queries
@@ -450,3 +451,35 @@ class NeatInstanceStore:
     def empty(self) -> bool:
         """Cheap way to check if the graph store is empty."""
         return not self.queries.select.has_data()
+
+    def diff(self, current_named_graph: URIRef, new_named_graph: URIRef) -> None:
+        """
+        Compare two named graphs and store diff results in dedicated named graphs.
+
+        Stores triples to add in DIFF_ADD and triples to delete in DIFF_DELETE.
+
+        Args:
+            current_named_graph: URI of the current named graph
+            new_named_graph: URI of the new/updated named graph
+
+        Raises:
+            NeatValueError: If either named graph doesn't exist in the store
+        """
+        if current_named_graph not in self.named_graphs:
+            raise NeatValueError(f"Current named graph not found: {current_named_graph}")
+        if new_named_graph not in self.named_graphs:
+            raise NeatValueError(f"New named graph not found: {new_named_graph}")
+
+        # Clear previous diff results using SPARQL
+        self.dataset.update(f"CLEAR SILENT GRAPH <{NAMED_GRAPH_NAMESPACE['DIFF_ADD']}>")
+        self.dataset.update(f"CLEAR SILENT GRAPH <{NAMED_GRAPH_NAMESPACE['DIFF_DELETE']}>")
+
+        # Store new diff results
+        self._add_triples(
+            self.queries.select.get_triples_to_add(current_named_graph, new_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),
+            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/v0/session/_base.py

@@ -25,6 +25,7 @@ from cognite.neat.v0.core._store._data_model import DataModelEntity
 from cognite.neat.v0.core._utils.auxiliary import local_import
 
 from ._collector import _COLLECTOR, Collector
+from ._diff import DiffAPI
 from ._drop import DropAPI
 from ._explore import ExploreAPI
 from ._fix import FixAPI
@@ -110,6 +111,7 @@ class NeatSession:
         self.template = TemplateAPI(self._state)
         self._explore = ExploreAPI(self._state)
         self.plugins = PluginAPI(self._state)
+        self._diff = DiffAPI(self._state)
         self.opt = OptAPI()
         self.opt._display()
         if load_engine != "skip" and (engine_version := load_neat_engine(client, load_engine)):

cognite/neat/v0/session/_diff.py

@@ -0,0 +1,51 @@
+from typing import cast
+
+from rdflib.query import ResultRow
+
+from cognite.neat.v0.core._constants import NAMED_GRAPH_NAMESPACE
+
+from ._state import SessionState
+
+
+class DiffAPI:
+    """Compare RDF graphs (private API)."""
+
+    def __init__(self, state: SessionState) -> None:
+        self._state = state
+
+    def instances(self, current_named_graph: str, new_named_graph: str) -> None:
+        """
+        Compare two named graphs and store diff results.
+
+        Results stored in DIFF_ADD and DIFF_DELETE named graphs.
+
+        Args:
+            current_named_graph: Name of the current graph (e.g., "CURRENT")
+            new_named_graph: Name of the new graph (e.g., "NEW")
+        """
+        current_uri = NAMED_GRAPH_NAMESPACE[current_named_graph]
+        new_uri = NAMED_GRAPH_NAMESPACE[new_named_graph]
+
+        self._state.instances.store.diff(current_uri, new_uri)
+        self._print_summary()
+
+    def _print_summary(self) -> None:
+        """Print diff summary with triple counts."""
+        store = self._state.instances.store
+
+        add_query = (
+            f"SELECT (COUNT(*) as ?count) WHERE {{ GRAPH <{NAMED_GRAPH_NAMESPACE['DIFF_ADD']}> {{ ?s ?p ?o }} }}"
+        )
+        delete_query = (
+            f"SELECT (COUNT(*) as ?count) WHERE {{ GRAPH <{NAMED_GRAPH_NAMESPACE['DIFF_DELETE']}> {{ ?s ?p ?o }} }}"
+        )
+
+        add_result = cast(ResultRow, next(iter(store.dataset.query(add_query))))
+        delete_result = cast(ResultRow, next(iter(store.dataset.query(delete_query))))
+
+        add_count = int(add_result[0])
+        delete_count = int(delete_result[0])
+
+        print("Diff complete:")
+        print(f"  {add_count} triples to add (stored in DIFF_ADD)")
+        print(f"  {delete_count} triples to delete (stored in DIFF_DELETE)")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite-neat
-Version: 0.123.43
+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/