cognite-neat 0.88.3__py3-none-any.whl → 0.90.0__py3-none-any.whl

cognite/neat/rules/{models/information/_converter.py → transformers/_converters.py}

@@ -1,40 +1,117 @@
 import re
+import warnings
+from abc import ABC, abstractmethod
 from collections import Counter, defaultdict
 from collections.abc import Collection
 from datetime import date, datetime
-from typing import TYPE_CHECKING, Literal
+from typing import Literal, TypeVar, cast
 
 from cognite.client.data_classes import data_modeling as dms
-
-from cognite.neat.rules.models import data_types
-from cognite.neat.rules.models._base import (
+from rdflib import Namespace
+
+from cognite.neat.constants import DMS_CONTAINER_PROPERTY_SIZE_LIMIT
+from cognite.neat.issues.warnings.user_modeling import ParentInDifferentSpaceWarning
+from cognite.neat.rules._shared import JustRules, OutRules, VerifiedRules
+from cognite.neat.rules.models import (
+    AssetRules,
+    DMSRules,
+    DomainRules,
     ExtensionCategory,
+    InformationRules,
     SchemaCompleteness,
     SheetList,
+    data_types,
 )
-from cognite.neat.rules.models._constants import DMS_CONTAINER_PROPERTY_SIZE_LIMIT
 from cognite.neat.rules.models.data_types import DataType
-from cognite.neat.rules.models.domain import DomainRules
+from cognite.neat.rules.models.dms import DMSMetadata, DMSProperty, DMSView
 from cognite.neat.rules.models.entities import (
     AssetEntity,
     AssetFields,
     ClassEntity,
     ContainerEntity,
     DMSUnknownEntity,
+    EdgeEntity,
     EntityTypes,
     MultiValueTypeInfo,
     ReferenceEntity,
     RelationshipEntity,
+    ReverseConnectionEntity,
     UnknownEntity,
     ViewEntity,
-    ViewPropertyEntity,
 )
+from cognite.neat.rules.models.information import InformationClass, InformationMetadata, InformationProperty
+
+from ._base import RulesTransformer
+
+T_VerifiedInRules = TypeVar("T_VerifiedInRules", bound=VerifiedRules)
+T_VerifiedOutRules = TypeVar("T_VerifiedOutRules", bound=VerifiedRules)
+
+
+class ConversionTransformer(RulesTransformer[T_VerifiedInRules, T_VerifiedOutRules], ABC):
+    """Base class for all conversion transformers."""
+
+    def transform(self, rules: T_VerifiedInRules | OutRules[T_VerifiedInRules]) -> JustRules[T_VerifiedOutRules]:
+        out = self._transform(self._to_rules(rules))
+        return JustRules(out)
+
+    @abstractmethod
+    def _transform(self, rules: T_VerifiedInRules) -> T_VerifiedOutRules:
+        raise NotImplementedError()
+
+
+class InformationToDMS(ConversionTransformer[InformationRules, DMSRules]):
+    """Converts InformationRules to DMSRules."""
+
+    def __init__(self, ignore_undefined_value_types: bool = False):
+        self.ignore_undefined_value_types = ignore_undefined_value_types
+
+    def _transform(self, rules: InformationRules) -> DMSRules:
+        return _InformationRulesConverter(rules).as_dms_rules(self.ignore_undefined_value_types)
+
+
+class InformationToAsset(ConversionTransformer[InformationRules, AssetRules]):
+    """Converts InformationRules to AssetRules."""
+
+    def _transform(self, rules: InformationRules) -> AssetRules:
+        return _InformationRulesConverter(rules).as_asset_architect_rules()
+
 
-from ._rules import InformationClass, InformationMetadata, InformationProperty, InformationRules
+class AssetToInformation(ConversionTransformer[AssetRules, InformationRules]):
+    """Converts AssetRules to InformationRules."""
 
-if TYPE_CHECKING:
-    from cognite.neat.rules.models.asset._rules import AssetRules
-    from cognite.neat.rules.models.dms._rules import DMSMetadata, DMSProperty, DMSRules
+    def _transform(self, rules: AssetRules) -> InformationRules:
+        return InformationRules.model_validate(rules.model_dump())
+
+
+class DMSToInformation(ConversionTransformer[DMSRules, InformationRules]):
+    """Converts DMSRules to InformationRules."""
+
+    def _transform(self, rules: DMSRules) -> InformationRules:
+        return _DMSRulesConverter(rules).as_information_rules()
+
+
+class ConvertToRules(ConversionTransformer[VerifiedRules, VerifiedRules]):
+    """Converts any rules to any rules."""
+
+    def __init__(self, out_cls: type[VerifiedRules]):
+        self._out_cls = out_cls
+
+    def _transform(self, rules: VerifiedRules) -> VerifiedRules:
+        if isinstance(rules, self._out_cls):
+            return rules
+        if isinstance(rules, InformationRules) and self._out_cls is DMSRules:
+            return InformationToDMS().transform(rules).rules
+        if isinstance(rules, InformationRules) and self._out_cls is AssetRules:
+            return InformationToAsset().transform(rules).rules
+        if isinstance(rules, AssetRules) and self._out_cls is InformationRules:
+            return AssetToInformation().transform(rules).rules
+        if isinstance(rules, AssetRules) and self._out_cls is DMSRules:
+            return InformationToDMS().transform(AssetToInformation().transform(rules)).rules
+        if isinstance(rules, DMSRules) and self._out_cls is InformationRules:
+            return DMSToInformation().transform(rules).rules
+        if isinstance(rules, DMSRules) and self._out_cls is AssetRules:
+            return InformationToAsset().transform(DMSToInformation().transform(rules)).rules
+        raise ValueError(f"Unsupported conversion from {type(rules)} to {self._out_cls}")
 
 
 class _InformationRulesConverter:
@@ -79,7 +156,7 @@ class _InformationRulesConverter:
             prefixes=self.rules.prefixes,
         )
 
-    def as_dms_rules(self) -> "DMSRules":
+    def as_dms_rules(self, ignore_undefined_value_types: bool = False) -> "DMSRules":
         from cognite.neat.rules.models.dms._rules import (
             DMSContainer,
             DMSProperty,
@@ -95,6 +172,8 @@ class _InformationRulesConverter:
         properties_by_class: dict[ClassEntity, list[DMSProperty]] = defaultdict(list)
         referenced_containers: dict[ContainerEntity, Counter[ClassEntity]] = defaultdict(Counter)
         for prop in self.rules.properties:
+            if ignore_undefined_value_types and isinstance(prop.value_type, UnknownEntity):
+                continue
             dms_property = self._as_dms_property(prop, default_space, default_version)
             properties_by_class[prop.class_].append(dms_property)
             if dms_property.container:
@@ -112,8 +191,10 @@ class _InformationRulesConverter:
             for cls_ in self.rules.classes
         ]
 
-        last_dms_rules = self.rules.last.as_dms_rules() if self.rules.last else None
-        ref_dms_rules = self.rules.reference.as_dms_rules() if self.rules.reference else None
+        last_dms_rules = _InformationRulesConverter(self.rules.last).as_dms_rules() if self.rules.last else None
+        ref_dms_rules = (
+            _InformationRulesConverter(self.rules.reference).as_dms_rules() if self.rules.reference else None
+        )
 
         class_by_entity = {cls_.class_: cls_ for cls_ in self.rules.classes}
         if self.rules.last:
@@ -197,7 +278,7 @@ class _InformationRulesConverter:
         from cognite.neat.rules.models.dms._rules import DMSProperty
 
         # returns property type, which can be ObjectProperty or DatatypeProperty
-        value_type: DataType | ViewEntity | ViewPropertyEntity | DMSUnknownEntity
+        value_type: DataType | ViewEntity | DMSUnknownEntity
         if isinstance(prop.value_type, DataType):
             value_type = prop.value_type
         elif isinstance(prop.value_type, UnknownEntity):
@@ -209,17 +290,22 @@ class _InformationRulesConverter:
         else:
             raise ValueError(f"Unsupported value type: {prop.value_type.type_}")
 
-        relation: Literal["direct", "edge", "reverse"] | None = None
-        if isinstance(value_type, ViewEntity | ViewPropertyEntity):
-            relation = "edge" if prop.is_list else "direct"
+        connection: Literal["direct"] | ReverseConnectionEntity | EdgeEntity | None = None
+        if isinstance(value_type, ViewEntity):
+            # Default connection type.
+            connection = EdgeEntity() if prop.is_list else "direct"
+
+        # defaulting to direct connection
+        elif isinstance(value_type, DMSUnknownEntity):
+            connection = "direct"
 
         container: ContainerEntity | None = None
         container_property: str | None = None
         is_list: bool | None = prop.is_list
         nullable: bool | None = not prop.is_mandatory
-        if relation == "edge":
+        if isinstance(connection, EdgeEntity):
             nullable = None
-        elif relation == "direct":
+        elif connection == "direct":
             nullable = True
             container, container_property = self._get_container(prop, default_space)
         else:
@@ -232,7 +318,7 @@ class _InformationRulesConverter:
             value_type=value_type,
             nullable=nullable,
             is_list=is_list,
-            connection=relation,
+            connection=connection,
             default=prop.default,
             reference=prop.reference,
             container=container,
@@ -326,3 +412,122 @@ class _InformationRulesConverter:
             return data_types.DateTime()
 
         return data_types.String()
+
+
+class _DMSRulesConverter:
+    def __init__(self, dms: DMSRules):
+        self.dms = dms
+
+    def as_domain_rules(self) -> "DomainRules":
+        raise NotImplementedError("DomainRules not implemented yet")
+
+    def as_information_rules(
+        self,
+    ) -> "InformationRules":
+        from cognite.neat.rules.models.information._rules import (
+            InformationClass,
+            InformationProperty,
+            InformationRules,
+        )
+
+        dms = self.dms.metadata
+
+        metadata = self._convert_metadata_to_info(dms)
+
+        classes = [
+            InformationClass(
+                # we do not want a version in class as we use URI for the class
+                class_=ClassEntity(prefix=view.class_.prefix, suffix=view.class_.suffix),
+                description=view.description,
+                parent=[
+                    # we do not want a version in class as we use URI for the class
+                    implemented_view.as_class(skip_version=True)
+                    # We only want parents in the same namespace, parent in a different namespace is a reference
+                    for implemented_view in view.implements or []
+                    if implemented_view.prefix == view.class_.prefix
+                ],
+                reference=self._get_class_reference(view),
+            )
+            for view in self.dms.views
+        ]
+
+        properties: list[InformationProperty] = []
+        value_type: DataType | ClassEntity | str
+        for property_ in self.dms.properties:
+            if isinstance(property_.value_type, DataType):
+                value_type = property_.value_type
+            elif isinstance(property_.value_type, ViewEntity):
+                value_type = ClassEntity(
+                    prefix=property_.value_type.prefix,
+                    suffix=property_.value_type.suffix,
+                )
+            elif isinstance(property_.value_type, DMSUnknownEntity):
+                value_type = UnknownEntity()
+            else:
+                raise ValueError(f"Unsupported value type: {property_.value_type.type_}")
+
+            properties.append(
+                InformationProperty(
+                    # Removing version
+                    class_=ClassEntity(suffix=property_.class_.suffix, prefix=property_.class_.prefix),
+                    property_=property_.view_property,
+                    value_type=value_type,
+                    description=property_.description,
+                    min_count=0 if property_.nullable or property_.nullable is None else 1,
+                    max_count=float("inf") if property_.is_list or property_.nullable is None else 1,
+                    reference=self._get_property_reference(property_),
+                )
+            )
+
+        return InformationRules(
+            metadata=metadata,
+            properties=SheetList[InformationProperty](data=properties),
+            classes=SheetList[InformationClass](data=classes),
+            last=_DMSRulesConverter(self.dms.last).as_information_rules() if self.dms.last else None,
+            reference=_DMSRulesConverter(self.dms.reference).as_information_rules() if self.dms.reference else None,
+        )
+
+    @classmethod
+    def _convert_metadata_to_info(cls, metadata: DMSMetadata) -> "InformationMetadata":
+        from cognite.neat.rules.models.information._rules import InformationMetadata
+
+        prefix = metadata.space
+        return InformationMetadata(
+            schema_=metadata.schema_,
+            data_model_type=metadata.data_model_type,
+            extension=metadata.extension,
+            prefix=prefix,
+            namespace=Namespace(f"https://purl.orgl/neat/{prefix}/"),
+            version=metadata.version,
+            description=metadata.description,
+            name=metadata.name or metadata.external_id,
+            creator=metadata.creator,
+            created=metadata.created,
+            updated=metadata.updated,
+        )
+
+    @classmethod
+    def _get_class_reference(cls, view: DMSView) -> ReferenceEntity | None:
+        parents_other_namespace = [parent for parent in view.implements or [] if parent.prefix != view.class_.prefix]
+        if len(parents_other_namespace) == 0:
+            return None
+        if len(parents_other_namespace) > 1:
+            warnings.warn(
+                ParentInDifferentSpaceWarning(view.view.as_id()),
+                stacklevel=2,
+            )
+        other_parent = parents_other_namespace[0]
+
+        return ReferenceEntity(prefix=other_parent.prefix, suffix=other_parent.suffix)
+
+    @classmethod
+    def _get_property_reference(cls, property_: DMSProperty) -> ReferenceEntity | None:
+        has_container_other_namespace = property_.container and property_.container.prefix != property_.class_.prefix
+        if not has_container_other_namespace:
+            return None
+        container = cast(ContainerEntity, property_.container)
+        return ReferenceEntity(
+            prefix=container.prefix,
+            suffix=container.suffix,
+            property=property_.container_property,
+        )

cognite/neat/rules/transformers/_map_onto.py

@@ -0,0 +1,97 @@
+from abc import ABC
+from collections import defaultdict
+
+from cognite.neat.rules._shared import JustRules, OutRules
+from cognite.neat.rules.models import DMSRules
+from cognite.neat.rules.models.dms import DMSProperty
+from cognite.neat.rules.models.entities import ReferenceEntity
+
+from ._base import RulesTransformer
+
+
+class MapOntoTransformers(RulesTransformer[DMSRules, DMSRules], ABC):
+    """Base class for transformers that map one rule onto another."""
+
+    ...
+
+
+class MapOneToOne(MapOntoTransformers):
+    """Takes transform data models and makes it into an extension of the reference data model.
+
+    Note this transformer mutates the input rules.
+
+    The argument view_extension_mapping is a dictionary where the keys are views of this data model,
+    and each value is the view of the reference data model that the view should extend. For example:
+
+    ```python
+    view_extension_mapping = {"Pump": "Asset"}
+    ```
+
+    This would make the view "Pump" in this data model extend the view "Asset" in the reference data model.
+    Note that all the keys in the dictionary must be external ids of views in this data model,
+    and all the values must be external ids of views in the reference data model.
+
+    Args:
+        reference: The reference data model
+        view_extension_mapping: A dictionary mapping views in this data model to views in the reference data model
+        default_extension: The default view in the reference data model that views in this
+            data model should extend if no mapping is provided.
+
+    """
+
+    def __init__(
+        self, reference: DMSRules, view_extension_mapping: dict[str, str], default_extension: str | None = None
+    ) -> None:
+        self.reference = reference
+        self.view_extension_mapping = view_extension_mapping
+        self.default_extension = default_extension
+
+    def transform(self, rules: DMSRules | OutRules[DMSRules]) -> JustRules[DMSRules]:
+        solution: DMSRules = self._to_rules(rules)
+        if solution.reference is not None:
+            raise ValueError("Reference already exists")
+        solution.reference = self.reference
+        view_by_external_id = {view.view.external_id: view for view in solution.views}
+        ref_view_by_external_id = {view.view.external_id: view for view in self.reference.views}
+
+        if invalid_views := set(self.view_extension_mapping.keys()) - set(view_by_external_id.keys()):
+            raise ValueError(f"Views are not in this dat model {invalid_views}")
+        if invalid_views := set(self.view_extension_mapping.values()) - set(ref_view_by_external_id.keys()):
+            raise ValueError(f"Views are not in the reference data model {invalid_views}")
+        if self.default_extension and self.default_extension not in ref_view_by_external_id:
+            raise ValueError(f"Default extension view not in the reference data model {self.default_extension}")
+
+        properties_by_view_external_id: dict[str, dict[str, DMSProperty]] = defaultdict(dict)
+        for prop in solution.properties:
+            properties_by_view_external_id[prop.view.external_id][prop.view_property] = prop
+
+        ref_properties_by_view_external_id: dict[str, dict[str, DMSProperty]] = defaultdict(dict)
+        for prop in self.reference.properties:
+            ref_properties_by_view_external_id[prop.view.external_id][prop.view_property] = prop
+
+        for view_external_id, view in view_by_external_id.items():
+            if view_external_id in self.view_extension_mapping:
+                ref_external_id = self.view_extension_mapping[view_external_id]
+            elif self.default_extension:
+                ref_external_id = self.default_extension
+            else:
+                continue
+
+            ref_view = ref_view_by_external_id[ref_external_id]
+            shared_properties = set(properties_by_view_external_id[view_external_id].keys()) & set(
+                ref_properties_by_view_external_id[ref_external_id].keys()
+            )
+            if shared_properties:
+                if view.implements is None:
+                    view.implements = [ref_view.view]
+                elif isinstance(view.implements, list) and ref_view.view not in view.implements:
+                    view.implements.append(ref_view.view)
+            for prop_name in shared_properties:
+                prop = properties_by_view_external_id[view_external_id][prop_name]
+                ref_prop = ref_properties_by_view_external_id[ref_external_id][prop_name]
+                if ref_prop.container and ref_prop.container_property:
+                    prop.container = ref_prop.container
+                    prop.container_property = ref_prop.container_property
+                prop.reference = ReferenceEntity.from_entity(ref_prop.view, ref_prop.view_property)
+
+        return JustRules(solution)

cognite/neat/rules/transformers/_pipelines.py

@@ -0,0 +1,61 @@
+from collections.abc import Iterable
+
+from cognite.neat.issues.errors import NeatValueError
+from cognite.neat.rules._shared import InputRules, MaybeRules, VerifiedRules
+from cognite.neat.rules.importers import BaseImporter
+from cognite.neat.rules.models import VERIFIED_RULES_BY_ROLE, RoleTypes
+
+from ._base import RulesPipeline, RulesTransformer
+from ._converters import ConvertToRules
+from ._verification import VerifyAnyRules
+
+
+class ImporterPipeline(RulesPipeline[InputRules, VerifiedRules]):
+    """This is a standard pipeline that verifies, convert and return the rules from the importer."""
+
+    def __init__(
+        self,
+        importer: BaseImporter[InputRules],
+        items: Iterable[RulesTransformer[InputRules, VerifiedRules]] | None = None,
+    ) -> None:
+        super().__init__(items or [])
+        self._importer = importer
+
+    @classmethod
+    def _create_pipeline(cls, importer: BaseImporter[InputRules], role: RoleTypes | None = None) -> "ImporterPipeline":
+        items: list[RulesTransformer] = [VerifyAnyRules(errors="continue")]
+        if role is not None:
+            out_cls = VERIFIED_RULES_BY_ROLE[role]
+            items.append(ConvertToRules(out_cls))
+        return cls(importer, items)
+
+    @classmethod
+    def try_verify(cls, importer: BaseImporter, role: RoleTypes | None = None) -> MaybeRules[VerifiedRules]:
+        """This is a standard pipeline that verifies, convert and return the rules from the importer.
+
+        Args:
+            importer: The importer to use.
+            role: The type of rules to convert to. If None, the rules will not be converted.
+
+        Returns:
+            The verified rules.
+        """
+        return cls._create_pipeline(importer, role).try_execute()
+
+    @classmethod
+    def verify(cls, importer: BaseImporter, role: RoleTypes | None = None) -> VerifiedRules:
+        """Verify the rules."""
+        return cls._create_pipeline(importer, role).execute()
+
+    def try_execute(self) -> MaybeRules[VerifiedRules]:
+        """Try to execute the pipeline from importer to rules."""
+        rules = self._importer.to_rules()
+        return self.try_transform(rules)
+
+    def execute(self) -> VerifiedRules:
+        """Execute the pipeline from importer to rules."""
+        rules = self._importer.to_rules()
+        out = self.transform(rules).get_rules()
+        if out is None:
+            raise NeatValueError("Failed to convert rules")
+        return out

cognite/neat/rules/transformers/_verification.py

@@ -0,0 +1,136 @@
+import warnings
+from abc import ABC
+from collections.abc import Iterator
+from contextlib import contextmanager
+from typing import Any, Literal
+
+from pydantic import ValidationError
+
+from cognite.neat.issues import IssueList, NeatError, NeatWarning
+from cognite.neat.issues.errors import NeatTypeError
+from cognite.neat.rules._shared import (
+    InputRules,
+    MaybeRules,
+    OutRules,
+    ReadRules,
+    T_InputRules,
+    T_VerifiedRules,
+    VerifiedRules,
+)
+from cognite.neat.rules.models import (
+    AssetInputRules,
+    AssetRules,
+    DMSInputRules,
+    DMSRules,
+    DomainInputRules,
+    DomainRules,
+    InformationInputRules,
+    InformationRules,
+)
+
+from ._base import RulesTransformer
+
+
+class VerificationTransformer(RulesTransformer[T_InputRules, T_VerifiedRules], ABC):
+    """Base class for all verification transformers."""
+
+    _rules_cls: type[T_VerifiedRules]
+
+    def __init__(self, errors: Literal["raise", "continue"]) -> None:
+        self.errors = errors
+
+    def transform(self, rules: T_InputRules | OutRules[T_InputRules]) -> MaybeRules[T_VerifiedRules]:
+        issues = IssueList()
+        in_: T_InputRules = self._to_rules(rules)
+        error_args: dict[str, Any] = {}
+        if isinstance(rules, ReadRules):
+            error_args = rules.read_context
+        verified_rules: T_VerifiedRules | None = None
+        with _handle_issues(issues, NeatError, NeatWarning, error_args) as future:
+            rules_cls = self._get_rules_cls(in_)
+            verified_rules = rules_cls.model_validate(in_.dump())  # type: ignore[assignment]
+
+        if (future.result == "failure" or issues.has_errors or verified_rules is None) and self.errors == "raise":
+            raise issues.as_errors()
+        return MaybeRules[T_VerifiedRules](
+            rules=verified_rules,
+            issues=issues,
+        )
+
+    def _get_rules_cls(self, in_: T_InputRules) -> type[T_VerifiedRules]:
+        return self._rules_cls
+
+
+class VerifyDMSRules(VerificationTransformer[DMSInputRules, DMSRules]):
+    """Class to verify DMS rules."""
+
+    _rules_cls = DMSRules
+
+
+class VerifyInformationRules(VerificationTransformer[InformationInputRules, InformationRules]):
+    """Class to verify Information rules."""
+
+    _rules_cls = InformationRules
+
+
+class VerifyAssetRules(VerificationTransformer[AssetInputRules, AssetRules]):
+    """Class to verify Asset rules."""
+
+    _rules_cls = AssetRules
+
+
+class VerifyAnyRules(VerificationTransformer[InputRules, VerifiedRules]):
+    """Class to verify arbitrary rules"""
+
+    def _get_rules_cls(self, in_: InputRules) -> type[VerifiedRules]:
+        if isinstance(in_, InformationInputRules):
+            return InformationRules
+        elif isinstance(in_, DMSInputRules):
+            return DMSRules
+        elif isinstance(in_, AssetInputRules):
+            return AssetRules
+        elif isinstance(in_, DomainInputRules):
+            return DomainRules
+        else:
+            raise NeatTypeError(f"Unsupported rules type: {type(in_)}")
+
+
+class _FutureResult:
+    def __init__(self) -> None:
+        self._result: Literal["success", "failure", "pending"] = "pending"
+
+    @property
+    def result(self) -> Literal["success", "failure", "pending"]:
+        return self._result
+
+
+@contextmanager
+def _handle_issues(
+    issues: IssueList,
+    error_cls: type[NeatError] = NeatError,
+    warning_cls: type[NeatWarning] = NeatWarning,
+    error_args: dict[str, Any] | None = None,
+) -> Iterator[_FutureResult]:
+    """This is an internal help function to handle issues and warnings.
+
+    Args:
+        issues: The issues list to append to.
+        error_cls: The class used to convert errors to issues.
+        warning_cls:  The class used to convert warnings to issues.
+
+    Returns:
+        FutureResult: A future result object that can be used to check the result of the context manager.
+    """
+    with warnings.catch_warnings(record=True) as warning_logger:
+        warnings.simplefilter("always")
+        future_result = _FutureResult()
+        try:
+            yield future_result
+        except ValidationError as e:
+            issues.extend(error_cls.from_pydantic_errors(e.errors(), **(error_args or {})))
+            future_result._result = "failure"
+        else:
+            future_result._result = "success"
+        finally:
+            if warning_logger:
+                issues.extend([warning_cls.from_warning(warning) for warning in warning_logger])  # type: ignore[misc]

cognite/neat/store/_base.py

@@ -12,7 +12,7 @@ from rdflib.plugins.stores.sparqlstore import SPARQLUpdateStore
 from cognite.neat.constants import DEFAULT_NAMESPACE
 from cognite.neat.graph._shared import MIMETypes
 from cognite.neat.graph.extractors import RdfFileExtractor, TripleExtractors
-from cognite.neat.graph.models import Triple
+from cognite.neat.graph.models import InstanceType, Triple
 from cognite.neat.graph.queries import Queries
 from cognite.neat.graph.transformers import Transformers
 from cognite.neat.rules.analysis import InformationAnalysis
@@ -173,7 +173,7 @@ class NeatGraphStore:
             )
         )
 
-    def read(self, class_: str) -> Iterable[tuple[str, dict[str, list[str]]]]:
+    def read(self, class_: str) -> Iterable[tuple[str, dict[str | InstanceType, list[str]]]]:
         """Read instances for given view from the graph store."""
 
         if not self.rules:

cognite/neat/store/_provenance.py

@@ -69,6 +69,10 @@ class Change(FrozenNeatObject):
     activity: Activity
     entity: Entity
     description: str
+    # triples that were added to the graph store
+    addition: list[tuple[URIRef, URIRef, URIRef | Literal]] | None = None
+    # triples that were removed from the graph store
+    subtraction: list[tuple[URIRef, URIRef, URIRef | Literal]] | None = None
 
     def as_triples(self):
         return self.agent.as_triples() + self.activity.as_triples() + self.entity.as_triples()
@@ -77,7 +81,12 @@ class Change(FrozenNeatObject):
     def record(cls, activity: str, start: datetime, end: datetime, description: str):
         """User friendly method to record a change that occurred in the graph store."""
         agent = Agent()
-        activity = Activity(used=activity, was_associated_with=agent, started_at_time=start, ended_at_time=end)
+        activity = Activity(
+            used=activity,
+            was_associated_with=agent,
+            started_at_time=start,
+            ended_at_time=end,
+        )
         entity = Entity(was_generated_by=activity, was_attributed_to=agent)
         return cls(agent, activity, entity, description)