cognite-neat 0.123.2__py3-none-any.whl → 0.127.30__py3-none-any.whl

cognite/neat/{core → v0/core}/_store/_instance.py

@@ -12,19 +12,20 @@ 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.core._instances._shared import quad_formats, rdflib_to_oxi_type
-from cognite.neat.core._instances.extractors import RdfFileExtractor, TripleExtractors
-from cognite.neat.core._instances.queries import Queries
-from cognite.neat.core._instances.transformers import Transformers
-from cognite.neat.core._issues import IssueList, catch_issues
-from cognite.neat.core._issues.errors import NeatValueError, OxigraphStorageLockedError
-from cognite.neat.core._shared import InstanceType, Triple
-from cognite.neat.core._utils.auxiliary import local_import
-from cognite.neat.core._utils.rdf_ import (
+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
+from cognite.neat.v0.core._instances.transformers import Transformers
+from cognite.neat.v0.core._issues import IssueList, catch_issues
+from cognite.neat.v0.core._issues.errors import NeatValueError, OxigraphStorageLockedError
+from cognite.neat.v0.core._shared import InstanceType, Triple
+from cognite.neat.v0.core._utils.auxiliary import local_import
+from cognite.neat.v0.core._utils.rdf_ import (
     add_triples_in_batch,
     remove_namespace_from_uri,
 )
-from cognite.neat.core._utils.text import humanize_collection
+from cognite.neat.v0.core._utils.text import humanize_collection
 
 from ._provenance import Change, Entity, Provenance
 
@@ -172,7 +173,7 @@ class NeatInstanceStore:
         local_import("pyoxigraph", "oxi")
         local_import("oxrdflib", "oxi")
         import oxrdflib
-        import pyoxigraph
+        import pyoxigraph  # type: ignore[import-untyped]
 
         try:
             oxi_store = pyoxigraph.Store(path=str(storage_dir) if storage_dir else None)
@@ -347,7 +348,7 @@ class NeatInstanceStore:
             )
             return issue_list
         _start = datetime.now(timezone.utc)
-        with catch_issues({}) as transform_issues:
+        with catch_issues() as transform_issues:
             transformer.transform(self.graph(named_graph))
         issue_list.extend(transform_issues)
         self.provenance.append(
@@ -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_graph_diff(new_named_graph, current_named_graph),
+            named_graph=NAMED_GRAPH_NAMESPACE["DIFF_ADD"],
+        )
+        self._add_triples(
+            self.queries.select.get_graph_diff(current_named_graph, new_named_graph),
+            named_graph=NAMED_GRAPH_NAMESPACE["DIFF_DELETE"],
+        )

cognite/neat/{core → v0/core}/_store/_provenance.py

@@ -24,9 +24,9 @@ from typing import Any, Generic, TypeVar
 
 from rdflib import PROV, RDF, Literal, URIRef
 
-from cognite.neat.core._constants import CDF_NAMESPACE, DEFAULT_NAMESPACE
-from cognite.neat.core._issues import IssueList
-from cognite.neat.core._shared import FrozenNeatObject, NeatList, Triple
+from cognite.neat.v0.core._constants import CDF_NAMESPACE, DEFAULT_NAMESPACE
+from cognite.neat.v0.core._issues import IssueList
+from cognite.neat.v0.core._shared import FrozenNeatObject, NeatList, Triple
 
 
 @dataclass(frozen=True)

cognite/neat/{core → v0/core}/_store/exceptions.py

@@ -2,10 +2,10 @@
 
 from dataclasses import dataclass
 
-from cognite.neat.core._data_model.importers import BaseImporter
-from cognite.neat.core._data_model.transformers import VerifiedDataModelTransformer
-from cognite.neat.core._instances.extractors import KnowledgeGraphExtractor
-from cognite.neat.core._issues import IssueList
+from cognite.neat.v0.core._data_model.importers import BaseImporter
+from cognite.neat.v0.core._data_model.transformers import VerifiedDataModelTransformer
+from cognite.neat.v0.core._instances.extractors import KnowledgeGraphExtractor
+from cognite.neat.v0.core._issues import IssueList
 
 from ._provenance import Activity
 

cognite/neat/{core → v0/core}/_utils/auth.py

@@ -11,7 +11,7 @@ from cognite.client.config import global_config
 from cognite.client.credentials import CredentialProvider, OAuthClientCredentials, OAuthInteractive, Token
 
 from cognite.neat import _version
-from cognite.neat.core._utils.auxiliary import local_import
+from cognite.neat.v0.core._utils.auxiliary import local_import
 
 __all__ = ["EnvironmentVariables", "get_cognite_client"]
 

cognite/neat/{core → v0/core}/_utils/auxiliary.py

@@ -11,7 +11,7 @@ from typing import Any
 
 from cognite.client.exceptions import CogniteDuplicatedError, CogniteReadTimeout
 
-from cognite.neat.core._issues.errors import NeatImportError
+from cognite.neat.v0.core._issues.errors._general import NeatImportError
 
 
 def local_import(module: str, extra: str) -> ModuleType:
@@ -161,3 +161,9 @@ def get_parameters_by_method(obj: object, prefix: str = "") -> dict[str, dict[st
 def get_parameters(obj: Callable) -> dict[str, type]:
     annotations = inspect.get_annotations(obj)
     return {name: annotations[name] for name in annotations if name != "return"}
+
+
+def filter_kwargs_by_method(kwargs: dict[str, Any], method: Callable) -> dict[str, Any]:
+    """Filter kwargs by method parameters."""
+    signature = inspect.signature(method)
+    return {k: v for k, v in kwargs.items() if k in signature.parameters}

cognite/neat/{core → v0/core}/_utils/collection_.py

@@ -2,8 +2,8 @@ from collections import Counter
 from collections.abc import Iterable, Sequence
 from typing import TypeVar
 
-from cognite.neat.core._config import GLOBAL_CONFIG
-from cognite.neat.core._constants import IN_PYODIDE
+from cognite.neat.v0.core._config import GLOBAL_CONFIG
+from cognite.neat.v0.core._constants import IN_PYODIDE
 
 T_Element = TypeVar("T_Element")
 

cognite/neat/{core → v0/core}/_utils/graph_transformations_report.py

@@ -2,7 +2,7 @@ from abc import ABC
 from dataclasses import dataclass
 from typing import Any
 
-from cognite.neat.core._shared import NeatList, NeatObject
+from cognite.neat.v0.core._shared import NeatList, NeatObject
 
 
 @dataclass

cognite/neat/{core → v0/core}/_utils/rdf_.py

@@ -8,7 +8,7 @@ from pydantic import HttpUrl, TypeAdapter, ValidationError
 from rdflib import Graph, Namespace, URIRef
 from rdflib import Literal as RdfLiteral
 
-from cognite.neat.core._constants import SPACE_URI_PATTERN
+from cognite.neat.v0.core._constants import SPACE_URI_PATTERN
 
 Triple: TypeAlias = tuple[URIRef, URIRef, RdfLiteral | URIRef]
 
@@ -147,19 +147,6 @@ def as_neat_compliant_uri(uri: URIRef) -> URIRef:
     return URIRef(f"{namespace}{compliant_uri}")
 
 
-def convert_rdflib_content(content: RdfLiteral | URIRef | dict | list, remove_namespace: bool = False) -> Any:
-    if isinstance(content, RdfLiteral):
-        return content.toPython()
-    elif isinstance(content, URIRef):
-        return remove_namespace_from_uri(content) if remove_namespace else content.toPython()
-    elif isinstance(content, dict):
-        return {key: convert_rdflib_content(value, remove_namespace) for key, value in content.items()}
-    elif isinstance(content, list):
-        return [convert_rdflib_content(item, remove_namespace) for item in content]
-    else:
-        return content
-
-
 def uri_to_short_form(URI: URIRef, prefixes: dict[str, Namespace]) -> str | URIRef:
     """Returns the short form of a URI if its namespace is present in the prefixes dict,
     otherwise returns the URI itself
@@ -179,6 +166,43 @@ def uri_to_short_form(URI: URIRef, prefixes: dict[str, Namespace]) -> str | URIR
     return min(uris, key=len)
 
 
+def uri_to_entity_components(uri: URIRef, prefixes: dict[str, Namespace]) -> tuple[str, str, str, str] | None:
+    """Converts a URI to its components: space, data_model_id, version, and entity_id.
+    Args:
+        uri: URI to be converted
+        prefixes: dict of prefixes
+
+    Returns:
+        tuple of space, data_model_id, version, and entity_id if found,
+        otherwise None
+
+    !!! note "URI Format"
+        The URI is expected to be in the form of `.../<space>/<data_model_id>/<version>/<entity_id>` to
+        be able to extract the components correctly.
+
+        An example of a valid entity URI is:
+
+        `https://cognitedata.com/cdf_cdm/CogniteCore/v1/CogniteAsset` , where:
+
+        - space is `cdf_cdm`
+        - data_model_id is `CogniteCore`
+        - version is `v1`
+        - entity_id is `CogniteAsset`
+
+        to be able to parse the URI correctly, the prefixes dict must have
+        the corresponding prefix registered:
+        {'cdf_cdm': Namespace('https://cognitedata.com/cdf_cdm/CogniteCore/v1/')}
+
+        for this method to return the correct components.
+    """
+    for prefix, namespace in prefixes.items():
+        if uri.startswith(namespace):
+            remainder = str(uri)[len(str(namespace)) :]
+            if (components := remainder.split("/")) and len(components) == 3 and all(components):
+                return prefix, components[0], components[1], components[2]
+    return None
+
+
 def _traverse(hierarchy: dict, graph: dict, names: list[str]) -> dict:
     """traverse the graph and return the hierarchy"""
     for name in names:

cognite/neat/{core → v0/core}/_utils/reader/_base.py

@@ -8,7 +8,7 @@ from urllib.parse import urlparse
 
 import requests
 
-from cognite.neat.core._issues.errors import NeatTypeError, NeatValueError
+from cognite.neat.v0.core._issues.errors import NeatTypeError, NeatValueError
 
 
 class NeatReader(ABC):

cognite/neat/{core → v0/core}/_utils/spreadsheet.py

@@ -8,7 +8,7 @@ from openpyxl import load_workbook
 from openpyxl.worksheet.datavalidation import DataValidation
 from openpyxl.worksheet.worksheet import Worksheet
 
-from cognite.neat.core._data_model._constants import get_internal_properties
+from cognite.neat.v0.core._data_model._constants import get_internal_properties
 
 
 @dataclass
@@ -98,6 +98,10 @@ def read_individual_sheet(
         # Special handling for Value Type column, #N/A is treated specially by NEAT it means Unknown
         raw["Value Type"] = raw["Value Type"].replace(float("nan"), "#N/A")
 
+    if "Concept" in raw.columns:
+        # Special handling for Concept column, #N/A is treated specially by NEAT it means Unknown
+        raw["Concept"] = raw["Concept"].replace(float("nan"), "#N/A")
+
     output = raw.replace(float("nan"), None).to_dict(orient="records")
     if return_read_info:
         # If no rows are skipped, row 1 is the header row.
@@ -139,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/core/_utils/tarjan.py

@@ -0,0 +1,44 @@
+from typing import TypeVar
+
+T = TypeVar("T")
+
+
+def tarjan(dependencies_by_id: dict[T, set[T]]) -> list[set[T]]:
+    """Returns the strongly connected components of the dependency graph
+     in topological order.
+    Args:
+        dependencies_by_id: A dictionary where the keys are ids and the values are sets of ids that the key depends on.
+    Returns:
+        A list of sets of ids that are strongly connected components in the dependency graph.
+    """
+
+    stack = []
+    stack_set = set()
+    index: dict[T, int] = {}
+    lowlink = {}
+    result = []
+
+    def visit(v: T) -> None:
+        index[v] = len(index)
+        lowlink[v] = index[v]
+        stack.append(v)
+        stack_set.add(v)
+        for w in dependencies_by_id.get(v, []):
+            if w not in index:
+                visit(w)
+                lowlink[v] = min(lowlink[w], lowlink[v])
+            elif w in stack_set:
+                lowlink[v] = min(lowlink[v], index[w])
+        if lowlink[v] == index[v]:
+            scc = set()
+            dependency: T | None = None
+            while v != dependency:
+                dependency = stack.pop()
+                scc.add(dependency)
+                stack_set.remove(dependency)
+            result.append(scc)
+
+    for view_id in dependencies_by_id.keys():
+        if view_id not in index:
+            visit(view_id)
+    return result

cognite/neat/{core → v0/core}/_utils/text.py

@@ -4,7 +4,7 @@ from collections.abc import Collection, Set
 from re import Pattern
 from typing import Any
 
-from cognite.neat.core._data_model._constants import get_reserved_words
+from cognite.neat.v0.core._data_model._constants import get_reserved_words
 
 PREPOSITIONS = frozenset(
     {

cognite/neat/{core → v0/core}/_utils/upload.py

@@ -3,9 +3,9 @@ from dataclasses import dataclass, field
 from functools import total_ordering
 from typing import Any, Generic
 
-from cognite.neat.core._issues import IssueList
-from cognite.neat.core._issues.errors import NeatValueError
-from cognite.neat.core._shared import T_ID, NeatList, NeatObject
+from cognite.neat.v0.core._issues import IssueList
+from cognite.neat.v0.core._issues.errors import NeatValueError
+from cognite.neat.v0.core._shared import T_ID, NeatList, NeatObject
 
 
 @total_ordering

cognite/neat/v0/plugins/__init__.py

@@ -0,0 +1,4 @@
+from ._data_model import DataModelImporterPlugin, DataModelTransformerPlugin
+from ._manager import get_plugin_manager
+
+__all__ = ["DataModelImporterPlugin", "DataModelTransformerPlugin", "get_plugin_manager"]

cognite/neat/v0/plugins/_base.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class NeatPlugin(ABC):
+    @abstractmethod
+    def configure(self, *args: Any, **kwargs: Any) -> Any:
+        """A method that all plugins must implement."""
+        raise NotImplementedError()

cognite/neat/v0/plugins/_data_model.py

@@ -0,0 +1,48 @@
+from pathlib import Path
+from typing import Any
+
+from cognite.neat.v0.core._data_model.importers._base import BaseImporter
+from cognite.neat.v0.core._data_model.transformers._base import VerifiedDataModelTransformer
+
+from ._base import NeatPlugin
+
+
+class DataModelImporterPlugin(NeatPlugin):
+    """This class is used an interface for data model import plugins.
+    Any plugin that is used for importing data models should inherit from this class.
+    It is expected to implement the `configure` method which returns a configured importer.
+    """
+
+    def configure(self, io: str | Path | None, **kwargs: Any) -> BaseImporter:
+        """Return a configure plugin for data model import.
+        Args:
+            io (str | Path | None): The input/output interface for the plugin.
+            **kwargs (Any): Additional keyword arguments for configuration.
+        Returns:
+            BaseImporter: A configured instance of the BaseImporter.
+        !!! note "Returns"
+            The method must return an instance of `BaseImporter` or its subclasses
+            meaning it must implement the `BaseImporter` interface.
+        """
+
+        raise NotImplementedError()
+
+
+class DataModelTransformerPlugin(NeatPlugin):
+    """This class is used as an interface for data model transformer plugins.
+    Any plugin that is used for transforming data models should inherit from this class.
+    It is expected to implement the `configure` method which returns a configured transformer.
+    """
+
+    def configure(self, **kwargs: Any) -> VerifiedDataModelTransformer:
+        """Return a configure plugin for data model import.
+        Args:
+            **kwargs (Any): Additional keyword arguments for configuration.
+        Returns:
+            VerifiedDataModelTransformer: A configured instance of the VerifiedDataModelTransformer.
+        !!! note "Returns"
+            The method must return an instance of `VerifiedDataModelTransformer` or its subclasses
+            meaning it must implement the `VerifiedDataModelTransformer` interface.
+        """
+
+        raise NotImplementedError()

cognite/neat/{plugins → v0/plugins}/_issues.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 
-from cognite.neat.core._issues.errors import _NEAT_ERRORS_BY_NAME, NeatError
+from cognite.neat.v0.core._issues.errors import _NEAT_ERRORS_BY_NAME, NeatError
 
 
 @dataclass(unsafe_hash=True)

cognite/neat/{plugins → v0/plugins}/_manager.py

@@ -1,21 +1,11 @@
 """Plugin manager for external plugins."""
 
 from importlib import metadata
-from typing import Any, ClassVar, TypeAlias, TypeVar, cast
+from typing import Any, ClassVar
 
+from ._base import NeatPlugin
+from ._data_model import DataModelImporterPlugin, DataModelTransformerPlugin
 from ._issues import PluginDuplicateError, PluginError, PluginLoadingError
-from .data_model.importers import DataModelImporterPlugin
-
-# Here we configure entry points where external plugins are going to be registered.
-plugins_entry_points = {
-    "cognite.neat.plugins.data_model.importers": DataModelImporterPlugin,
-}
-
-#: Type alias for all supported plugin types
-NeatPlugin: TypeAlias = DataModelImporterPlugin
-
-# Generic type variable for plugin types
-T_NeatPlugin = TypeVar("T_NeatPlugin", bound=NeatPlugin)
 
 
 class Plugin:
@@ -47,13 +37,14 @@ class PluginManager:
     """Plugin manager for external plugins."""
 
     _plugins_entry_points: ClassVar[dict[str, type[NeatPlugin]]] = {
-        "cognite.neat.plugins.data_model.importers": DataModelImporterPlugin,
+        "cognite.neat.v0.plugins.data_model.importers": DataModelImporterPlugin,
+        "cognite.neat.v0.plugins.data_model.transformers": DataModelTransformerPlugin,
     }
 
     def __init__(self, plugins: dict[tuple[str, type[NeatPlugin]], Any]) -> None:
         self._plugins = plugins
 
-    def get(self, name: str, type_: type[T_NeatPlugin]) -> type[T_NeatPlugin]:
+    def get(self, name: str, type_: type[NeatPlugin]) -> type[NeatPlugin]:
         """
         Returns desired plugin
 
@@ -63,7 +54,7 @@ class PluginManager:
         """
         try:
             plugin_class = self._plugins[(name, type_)]
-            return cast(type[T_NeatPlugin], plugin_class)
+            return plugin_class
         except KeyError:
             raise PluginError(plugin_name=name, plugin_type=type_.__name__) from None
 

cognite/neat/{session → v0/session}/_base.py

@@ -5,26 +5,27 @@ from cognite.client import CogniteClient
 from cognite.client import data_modeling as dm
 
 from cognite.neat import _version
-from cognite.neat.core._client import NeatClient
-from cognite.neat.core._data_model import importers
-from cognite.neat.core._data_model.models import PhysicalDataModel
-from cognite.neat.core._data_model.models.conceptual._verified import (
+from cognite.neat.v0.core._client import NeatClient
+from cognite.neat.v0.core._data_model import importers
+from cognite.neat.v0.core._data_model.models import PhysicalDataModel
+from cognite.neat.v0.core._data_model.models.conceptual._verified import (
     ConceptualDataModel,
 )
-from cognite.neat.core._data_model.transformers import (
+from cognite.neat.v0.core._data_model.transformers import (
     ConceptualToPhysical,
     MergeConceptualDataModels,
     MergePhysicalDataModels,
     ToDMSCompliantEntities,
     VerifyConceptualDataModel,
 )
-from cognite.neat.core._issues import IssueList
-from cognite.neat.core._issues.errors import RegexViolationError
-from cognite.neat.core._issues.errors._general import NeatImportError
-from cognite.neat.core._store._data_model import DataModelEntity
-from cognite.neat.core._utils.auxiliary import local_import
+from cognite.neat.v0.core._issues import IssueList
+from cognite.neat.v0.core._issues.errors import RegexViolationError
+from cognite.neat.v0.core._issues.errors._general import NeatImportError
+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)):
@@ -173,6 +175,7 @@ class NeatSession:
             "Convert to physical",
             has_physical_data_model=False,
             has_conceptual_data_model=True,
+            can_convert_to_physical_data_model=True,
         )
         converter = ConceptualToPhysical(reserved_properties=reserved_properties, client=self._state.client)
 

cognite/neat/{session → v0/session}/_collector.py

@@ -11,7 +11,7 @@ from typing import Any
 from mixpanel import Consumer, Mixpanel  # type: ignore[import-untyped]
 
 from cognite.neat._version import __version__
-from cognite.neat.core._constants import IN_NOTEBOOK, IN_PYODIDE
+from cognite.neat.v0.core._constants import IN_NOTEBOOK, IN_PYODIDE
 
 _NEAT_MIXPANEL_TOKEN: str = "bd630ad149d19999df3989c3a3750c4f"
 

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/{session → v0/session}/_drop.py

@@ -5,9 +5,9 @@ from typing import Literal
 from cognite.client.utils.useful_types import SequenceNotStr
 from rdflib import URIRef
 
-from cognite.neat.core._constants import COGNITE_MODELS
-from cognite.neat.core._data_model.transformers import DropModelViews
-from cognite.neat.core._issues import IssueList
+from cognite.neat.v0.core._constants import COGNITE_MODELS
+from cognite.neat.v0.core._data_model.transformers import DropModelViews
+from cognite.neat.v0.core._issues import IssueList
 
 from ._state import SessionState
 from .exceptions import NeatSessionError, session_class_wrapper

cognite/neat/{session → v0/session}/_explore.py

@@ -3,8 +3,8 @@ from typing import cast
 import pandas as pd
 from rdflib import URIRef
 
-from cognite.neat.core._utils.rdf_ import remove_namespace_from_uri
-from cognite.neat.core._utils.text import humanize_collection
+from cognite.neat.v0.core._utils.rdf_ import remove_namespace_from_uri
+from cognite.neat.v0.core._utils.text import humanize_collection
 
 from ._state import SessionState
 from .exceptions import NeatSessionError, session_class_wrapper

cognite/neat/{session → v0/session}/_fix.py

@@ -1,7 +1,7 @@
-from cognite.neat.core._data_model.transformers import (
+from cognite.neat.v0.core._data_model.transformers import (
     ToCompliantEntities,
 )
-from cognite.neat.core._issues._base import IssueList
+from cognite.neat.v0.core._issues._base import IssueList
 
 from ._state import SessionState
 from .exceptions import session_class_wrapper