cognite-neat 0.103.0__py3-none-any.whl → 0.104.0__py3-none-any.whl

cognite/neat/_graph/transformers/_value_type.py

@@ -5,17 +5,18 @@ from urllib.parse import quote
 
 import rdflib
 from rdflib import RDF, XSD, Graph, Namespace, URIRef
+from rdflib.query import ResultRow
 
 from cognite.neat._constants import UNKNOWN_TYPE
 from cognite.neat._graph.queries import Queries
-from cognite.neat._issues.warnings import NeatValueWarning, PropertyDataTypeConversionWarning
+from cognite.neat._issues.warnings import PropertyDataTypeConversionWarning
 from cognite.neat._utils.auxiliary import string_to_ideal_type
-from cognite.neat._utils.collection_ import iterate_progress_bar
 from cognite.neat._utils.rdf_ import get_namespace, remove_namespace_from_uri
 
-from ._base import BaseTransformer
+from ._base import BaseTransformer, BaseTransformerStandardised, RowTransformationOutput
 
 
+# TODO: Standardise
 class SplitMultiValueProperty(BaseTransformer):
     description: str = (
         "SplitMultiValueProperty is a transformer that splits a "
@@ -75,34 +76,11 @@ class SplitMultiValueProperty(BaseTransformer):
                     graph.add((s, new_property, o))
 
 
-class ConvertLiteral(BaseTransformer):
+class ConvertLiteral(BaseTransformerStandardised):
     description: str = "ConvertLiteral is a transformer that improve data typing of a literal value."
     _use_only_once: bool = False
     _need_changes = frozenset({})
 
-    _count_by_properties = """SELECT (COUNT(?value) AS ?valueCount)
-    WHERE {{
-      ?instance a <{subject_type}> .
-      ?instance <{subject_predicate}> ?value
-       FILTER(isLiteral(?value))
-    }}"""
-
-    _count_by_properties_uri = """SELECT (COUNT(?value) AS ?valueCount)
-        WHERE {{
-          ?instance a <{subject_type}> .
-          ?instance <{subject_predicate}> ?value
-           FILTER(isIRI(?value))
-        }}"""
-
-    _properties = """SELECT ?instance ?value
-    WHERE {{
-      ?instance a <{subject_type}> .
-      ?instance <{subject_predicate}> ?value
-
-      FILTER(isLiteral(?value))
-
-    }}"""
-
     def __init__(
         self,
         subject_type: URIRef,
@@ -115,89 +93,55 @@ class ConvertLiteral(BaseTransformer):
         self._type_name = remove_namespace_from_uri(subject_type)
         self._property_name = remove_namespace_from_uri(subject_predicate)
 
-    def transform(self, graph: Graph) -> None:
-        count_connection_query = self._count_by_properties_uri.format(
-            subject_type=self.subject_type, subject_predicate=self.subject_predicate
-        )
-        connection_count_res = list(graph.query(count_connection_query))
-        connection_count = int(connection_count_res[0][0])  # type: ignore [index, arg-type]
-
-        if connection_count > 0:
+    def _skip_count_query(self) -> str:
+        query = """SELECT (COUNT(?value) AS ?valueCount)
+                    WHERE {{
+                      ?instance a <{subject_type}> .
+                      ?instance <{subject_predicate}> ?value
+                       FILTER(isIRI(?value))
+                    }}"""
+        return query.format(subject_type=self.subject_type, subject_predicate=self.subject_predicate)
+
+    def _count_query(self) -> str:
+        query = """SELECT (COUNT(?value) AS ?valueCount)
+                    WHERE {{
+                      ?instance a <{subject_type}> .
+                      ?instance <{subject_predicate}> ?value
+                       FILTER(isLiteral(?value))
+                    }}"""
+        return query.format(subject_type=self.subject_type, subject_predicate=self.subject_predicate)
+
+    def _iterate_query(self) -> str:
+        query = """SELECT ?instance ?value
+                    WHERE {{
+                      ?instance a <{subject_type}> .
+                      ?instance <{subject_predicate}> ?value
+                      FILTER(isLiteral(?value))
+                    }}"""
+        return query.format(subject_type=self.subject_type, subject_predicate=self.subject_predicate)
+
+    def operation(self, query_result_row: ResultRow) -> RowTransformationOutput:
+        row_output = RowTransformationOutput()
+
+        instance, literal = query_result_row
+        value = cast(rdflib.Literal, literal).toPython()
+
+        try:
+            converted_value = self.conversion(value)
+        except Exception as e:
             warnings.warn(
-                NeatValueWarning(
-                    f"Skipping {connection_count} of {self._type_name}.{self._property_name} "
-                    f"as these are connections and not data values."
-                ),
+                PropertyDataTypeConversionWarning(str(instance), self._type_name, self._property_name, str(e)),
                 stacklevel=2,
             )
+        row_output.add_triples.append((instance, self.subject_predicate, rdflib.Literal(converted_value)))  # type: ignore[arg-type]
+        row_output.remove_triples.append((instance, self.subject_predicate, literal))  # type: ignore[arg-type]
+        row_output.instances_modified_count += 1
+
+        return row_output
 
-        count_query = self._count_by_properties.format(
-            subject_type=self.subject_type, subject_predicate=self.subject_predicate
-        )
-
-        property_count_res = list(graph.query(count_query))
-        property_count = int(property_count_res[0][0])  # type: ignore [index, arg-type]
-        iterate_query = self._properties.format(
-            subject_type=self.subject_type, subject_predicate=self.subject_predicate
-        )
-
-        for instance, literal in iterate_progress_bar(  # type: ignore[misc]
-            graph.query(iterate_query),
-            total=property_count,
-            description=f"Converting {self._type_name}.{self._property_name}.",
-        ):
-            value = cast(rdflib.Literal, literal).toPython()
-            try:
-                converted_value = self.conversion(value)
-            except Exception as e:
-                warnings.warn(
-                    PropertyDataTypeConversionWarning(str(instance), self._type_name, self._property_name, str(e)),
-                    stacklevel=2,
-                )
-                continue
-
-            graph.add((instance, self.subject_predicate, rdflib.Literal(converted_value)))
-            graph.remove((instance, self.subject_predicate, literal))
-
-
-class LiteralToEntity(BaseTransformer):
-    description = "Converts a literal value to new entity"
 
-    _count_properties_of_type = """SELECT (COUNT(?property) AS ?propertyCount)
-    WHERE {{
-      ?instance a <{subject_type}> .
-      ?instance <{subject_predicate}> ?property
-      FILTER(isLiteral(?property))
-    }}"""
-    _count_connections_of_type = """SELECT (COUNT(?property) AS ?propertyCount)
-    WHERE {{
-      ?instance a <{subject_type}> .
-      ?instance <{subject_predicate}> ?property
-      FILTER(isIRI(?property))
-    }}"""
-
-    _properties_of_type = """SELECT ?instance ?property
-    WHERE {{
-      ?instance a <{subject_type}> .
-      ?instance <{subject_predicate}> ?property
-      FILTER(isLiteral(?property))
-    }}"""
-
-    _count_properties = """SELECT (COUNT(?property) AS ?propertyCount)
-    WHERE {{
-      ?instance <{subject_predicate}> ?property
-      FILTER(isLiteral(?property))
-    }}"""
-    _count_connections = """SELECT (COUNT(?property) AS ?propertyCount)
-        WHERE {{
-          ?instance <{subject_predicate}> ?property
-          FILTER(isIRI(?property))
-        }}"""
-    _properties = """SELECT ?instance ?property
-    WHERE {{
-      ?instance <{subject_predicate}> ?property
-      FILTER(isLiteral(?property))
-    }}"""
+class LiteralToEntity(BaseTransformerStandardised):
+    description = "Converts a literal value to new entity"
 
     def __init__(
         self, subject_type: URIRef | None, subject_predicate: URIRef, entity_type: str, new_property: str | None = None
@@ -207,54 +151,75 @@ class LiteralToEntity(BaseTransformer):
         self.entity_type = entity_type
         self.new_property = new_property
 
-    def transform(self, graph: Graph) -> None:
+    def _iterate_query(self) -> str:
         if self.subject_type is None:
-            count_query = self._count_properties.format(subject_predicate=self.subject_predicate)
-            iterate_query = self._properties.format(subject_predicate=self.subject_predicate)
-            connection_count_query = self._count_connections.format(subject_predicate=self.subject_predicate)
+            query = """SELECT ?instance ?property
+            WHERE {{
+              ?instance <{subject_predicate}> ?property
+              FILTER(isLiteral(?property))
+            }}"""
+            return query.format(subject_predicate=self.subject_predicate)
         else:
-            count_query = self._count_properties_of_type.format(
-                subject_type=self.subject_type, subject_predicate=self.subject_predicate
-            )
-            iterate_query = self._properties_of_type.format(
-                subject_type=self.subject_type, subject_predicate=self.subject_predicate
-            )
-            connection_count_query = self._count_connections_of_type.format(
-                subject_type=self.subject_type, subject_predicate=self.subject_predicate
-            )
-
-        connection_count_res = list(graph.query(connection_count_query))
-        connection_count = int(connection_count_res[0][0])  # type: ignore [index, arg-type]
-        if connection_count > 0:
-            warnings.warn(
-                NeatValueWarning(
-                    f"Skipping {connection_count} of {remove_namespace_from_uri(self.subject_predicate)} "
-                    f"as these are connections and not data values."
-                ),
-                stacklevel=2,
-            )
-
-        property_count_res = list(graph.query(count_query))
-        property_count = int(property_count_res[0][0])  # type: ignore [index, arg-type]
-
-        instance: URIRef
-        description = f"Creating {remove_namespace_from_uri(self.subject_predicate)}."
-        if self.subject_type is not None:
-            description = (
-                f"Creating {remove_namespace_from_uri(self.subject_type)}."
-                f"{remove_namespace_from_uri(self.subject_predicate)}."
-            )
-        for instance, literal in iterate_progress_bar(  # type: ignore[misc, assignment]
-            graph.query(iterate_query),
-            total=property_count,
-            description=description,
-        ):
-            value = cast(rdflib.Literal, literal).toPython()
-            namespace = Namespace(get_namespace(instance))
-            entity_type = namespace[self.entity_type]
-            new_entity = namespace[f"{self.entity_type}_{quote(value)!s}"]
-            graph.add((new_entity, RDF.type, entity_type))
-            if self.new_property is not None:
-                graph.add((new_entity, namespace[self.new_property], rdflib.Literal(value)))
-            graph.add((instance, self.subject_predicate, new_entity))
-            graph.remove((instance, self.subject_predicate, literal))
+            query = """SELECT ?instance ?property
+                WHERE {{
+                  ?instance a <{subject_type}> .
+                  ?instance <{subject_predicate}> ?property
+                  FILTER(isLiteral(?property))
+                }}"""
+            return query.format(subject_type=self.subject_type, subject_predicate=self.subject_predicate)
+
+    def _skip_count_query(self) -> str:
+        if self.subject_type is None:
+            query = """SELECT (COUNT(?property) AS ?propertyCount)
+                        WHERE {{
+                          ?instance <{subject_predicate}> ?property
+                          FILTER(isIRI(?property))
+                        }}"""
+            return query.format(subject_predicate=self.subject_predicate)
+        else:
+            query = """SELECT (COUNT(?property) AS ?propertyCount)
+                        WHERE {{
+                          ?instance a <{subject_type}> .
+                          ?instance <{subject_predicate}> ?property
+                          FILTER(isIRI(?property))
+                        }}"""
+            return query.format(subject_type=self.subject_type, subject_predicate=self.subject_predicate)
+
+    def _count_query(self) -> str:
+        if self.subject_type is None:
+            query = """SELECT (COUNT(?property) AS ?propertyCount)
+                WHERE {{
+                  ?instance <{subject_predicate}> ?property
+                  FILTER(isLiteral(?property))
+                }}"""
+            return query.format(subject_predicate=self.subject_predicate)
+        else:
+            query = """SELECT (COUNT(?property) AS ?propertyCount)
+                        WHERE {{
+                          ?instance a <{subject_type}> .
+                          ?instance <{subject_predicate}> ?property
+                          FILTER(isLiteral(?property))
+                        }}"""
+
+            return query.format(subject_type=self.subject_type, subject_predicate=self.subject_predicate)
+
+    def operation(self, query_result_row: ResultRow) -> RowTransformationOutput:
+        row_output = RowTransformationOutput()
+
+        instance, literal = query_result_row
+        value = cast(rdflib.Literal, literal).toPython()
+        namespace = Namespace(get_namespace(instance))  # type: ignore[arg-type]
+        entity_type = namespace[self.entity_type]
+        new_entity = namespace[f"{self.entity_type}_{quote(value)!s}"]
+        row_output.add_triples.append((new_entity, RDF.type, entity_type))
+        row_output.instances_added_count += 1  # we add one new entity
+
+        if self.new_property is not None:
+            row_output.add_triples.append((new_entity, namespace[self.new_property], rdflib.Literal(value)))  # type: ignore[arg-type]
+            row_output.instances_modified_count += 1  # we modify the new entity
+
+        row_output.add_triples.append((instance, self.subject_predicate, new_entity))  # type: ignore[arg-type]
+        row_output.remove_triples.append((instance, self.subject_predicate, literal))  # type: ignore[arg-type]
+        row_output.instances_modified_count += 1  # we modify the old entity
+
+        return row_output

cognite/neat/_issues/_base.py

@@ -390,11 +390,16 @@ class NeatIssueList(list, Sequence[T_NeatIssue], ABC):
     """This is a generic list of NeatIssues."""
 
     def __init__(
-        self, issues: Sequence[T_NeatIssue] | None = None, title: str | None = None, action: str | None = None
+        self,
+        issues: Sequence[T_NeatIssue] | None = None,
+        title: str | None = None,
+        action: str | None = None,
+        hint: str | None = None,
     ):
         super().__init__(issues or [])
         self.title = title
         self.action = action
+        self.hint = hint
 
     @property
     def errors(self) -> Self:
@@ -406,6 +411,11 @@ class NeatIssueList(list, Sequence[T_NeatIssue], ABC):
         """Return True if this list contains any errors."""
         return any(isinstance(issue, NeatError) for issue in self)
 
+    @property
+    def has_warnings(self) -> bool:
+        """Return True if this list contains any warnings."""
+        return any(isinstance(issue, NeatWarning) for issue in self)
+
     @property
     def warnings(self) -> Self:
         """Return all the warnings in this list."""
@@ -455,14 +465,31 @@ class IssueList(NeatIssueList[NeatIssue]):
     """This is a list of NeatIssues."""
 
     def _repr_html_(self) -> str | None:
-        if not self:
-            return "<p>'No issues found'</p>"
-        df = self.to_pandas()
-        agg_df = df["NeatIssue"].value_counts().to_frame()
-        if len(agg_df) < 10:
-            return agg_df._repr_html_()  # type: ignore[operator]
+        if self.action and not self:
+            header = f"Success: {self.action}"
+        elif self.action and self.has_errors:
+            header = f"Failed: {self.action}"
+        elif self.action and self.has_warnings:
+            header = f"Succeeded with warnings: {self.action}"
+        elif not self:
+            header = "No issues found"
         else:
-            return agg_df.head()._repr_html_()  # type: ignore[operator]
+            header = ""
+
+        body = f"<p>{header}</p>"
+
+        if self:
+            df = self.to_pandas()
+            agg_df = df["NeatIssue"].value_counts().to_frame()
+            if len(agg_df) < 10:
+                table = agg_df._repr_html_()  # type: ignore[operator]
+            else:
+                table = agg_df.head()._repr_html_()  # type: ignore[operator]
+            body += f"<br />{table}"
+
+            if self.hint:
+                body += f"<br />Hint: {self.hint}"
+        return body
 
 
 T_Cls = TypeVar("T_Cls")

cognite/neat/_issues/warnings/_resources.py

@@ -21,7 +21,7 @@ class ResourceRegexViolationWarning(ResourceNeatWarning):
 
     fix = (
         "Either export the data model and make the necessary changes manually"
-        " or run prepare.cdf_compliant_external_ids."
+        " or run prepare.data_model.cdf_compliant_external_ids."
     )
 
     location: str

cognite/neat/_rules/_shared.py

@@ -1,8 +1,6 @@
-from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from typing import Any, Generic, TypeAlias, TypeVar
 
-from cognite.neat._issues import IssueList
 from cognite.neat._rules.models import (
     DMSRules,
     InformationRules,
@@ -11,46 +9,32 @@ from cognite.neat._rules.models.dms._rules_input import DMSInputRules
 from cognite.neat._rules.models.information._rules_input import InformationInputRules
 
 VerifiedRules: TypeAlias = InformationRules | DMSRules
-InputRules: TypeAlias = DMSInputRules | InformationInputRules
-Rules: TypeAlias = DMSInputRules | InformationInputRules | InformationRules | DMSRules
-T_Rules = TypeVar("T_Rules", bound=Rules)
+
 T_VerifiedRules = TypeVar("T_VerifiedRules", bound=VerifiedRules)
+InputRules: TypeAlias = DMSInputRules | InformationInputRules
 T_InputRules = TypeVar("T_InputRules", bound=InputRules)
 
 
 @dataclass
-class OutRules(Generic[T_Rules], ABC):
-    """This is a base class for all rule states."""
-
-    @abstractmethod
-    def get_rules(self) -> T_Rules | None:
-        """Get the rules from the state."""
-        raise NotImplementedError()
-
-
-@dataclass
-class JustRules(OutRules[T_Rules]):
-    """This represents a rule that exists"""
+class ReadRules(Generic[T_InputRules]):
+    """This represents a rules that has been read."""
 
-    rules: T_Rules
-
-    def get_rules(self) -> T_Rules:
-        return self.rules
-
-
-@dataclass
-class MaybeRules(OutRules[T_Rules]):
-    """This represents a rule that may or may not exist"""
+    rules: T_InputRules | None
+    read_context: dict[str, Any]
 
-    rules: T_Rules | None
-    issues: IssueList
+    @classmethod
+    def display_type_name(cls) -> str:
+        return "UnverifiedModel"
 
-    def get_rules(self) -> T_Rules | None:
-        return self.rules
+    @property
+    def display_name(self):
+        if self.rules is None:
+            return "FailedRead"
+        return self.rules.display_name
 
 
-@dataclass
-class ReadRules(MaybeRules[T_Rules]):
-    """This represents a rule that does not exist"""
+ReadInputRules: TypeAlias = ReadRules[DMSInputRules] | ReadRules[InformationInputRules]
+T_ReadInputRules = TypeVar("T_ReadInputRules", bound=ReadInputRules)
 
-    read_context: dict[str, Any]
+Rules: TypeAlias = InformationRules | DMSRules | ReadRules[DMSInputRules] | ReadRules[InformationInputRules]
+T_Rules = TypeVar("T_Rules", bound=Rules)

cognite/neat/_rules/exporters/_base.py

@@ -1,13 +1,19 @@
 from abc import ABC, abstractmethod
 from collections.abc import Iterable
+from functools import lru_cache
 from pathlib import Path
-from typing import Generic, TypeVar
+from types import UnionType
+from typing import TYPE_CHECKING, Generic, TypeVar, Union, get_args, get_origin
 
 from cognite.neat._client import NeatClient
+from cognite.neat._constants import DEFAULT_NAMESPACE
 from cognite.neat._rules._shared import T_VerifiedRules
 from cognite.neat._utils.auxiliary import class_html_doc
 from cognite.neat._utils.upload import UploadResult, UploadResultList
 
+if TYPE_CHECKING:
+    from cognite.neat._store._provenance import Agent as ProvenanceAgent
+
 T_Export = TypeVar("T_Export")
 
 
@@ -27,8 +33,28 @@ class BaseExporter(ABC, Generic[T_VerifiedRules, T_Export]):
     def _repr_html_(cls) -> str:
         return class_html_doc(cls, include_factory_methods=False)
 
+    @property
+    def agent(self) -> "ProvenanceAgent":
+        """Provenance agent for the importer."""
+        from cognite.neat._store._provenance import Agent as ProvenanceAgent
+
+        return ProvenanceAgent(id_=DEFAULT_NAMESPACE[f"agent/{type(self).__name__}"])
+
+    @property
+    def description(self) -> str:
+        return "MISSING DESCRIPTION"
+
+    @classmethod
+    @lru_cache(maxsize=1)
+    def source_types(cls) -> tuple[type, ...]:
+        base_exporter = cls.__orig_bases__[0]  # type: ignore[attr-defined]
+        source_type = get_args(base_exporter)[0]
+        if get_origin(source_type) in [Union, UnionType]:
+            return get_args(source_type)
+        return (source_type,)
+
 
-class CDFExporter(BaseExporter[T_VerifiedRules, T_Export]):
+class CDFExporter(BaseExporter[T_VerifiedRules, T_Export], ABC):
     @abstractmethod
     def export_to_cdf_iterable(
         self, rules: T_VerifiedRules, client: NeatClient, dry_run: bool = False

cognite/neat/_rules/exporters/_rules2dms.py

@@ -109,6 +109,10 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
         self._schema: DMSSchema | None = None
         self.remove_cdf_spaces = remove_cdf_spaces
 
+    @property
+    def description(self) -> str:
+        return "Export verified DMS Model to CDF."
+
     def export_to_file(self, rules: DMSRules, filepath: Path) -> None:
         """Export the rules to a file(s).
 

cognite/neat/_rules/exporters/_rules2excel.py

@@ -68,6 +68,7 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
         styling: Style = "default",
         new_model_id: tuple[str, str] | None = None,
         sheet_prefix: str | None = None,
+        reference_rules_with_prefix: tuple[VerifiedRules, str] | None = None,
     ):
         self.sheet_prefix = sheet_prefix or ""
         if styling not in self.style_options:
@@ -75,6 +76,11 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
         self.styling = styling
         self._styling_level = self.style_options.index(styling)
         self.new_model_id = new_model_id
+        self.reference_rules_with_prefix = reference_rules_with_prefix
+
+    @property
+    def description(self) -> str:
+        return "Export verified model to Excel."
 
     def export_to_file(self, rules: VerifiedRules, filepath: Path) -> None:
         """Exports transformation rules to excel file."""
@@ -94,6 +100,11 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
 
         self._write_metadata_sheet(workbook, dumped_user_rules["Metadata"], sheet_prefix=self.sheet_prefix)
         self._write_sheets(workbook, dumped_user_rules, rules, sheet_prefix=self.sheet_prefix)
+        if self.reference_rules_with_prefix:
+            reference_rules, prefix = self.reference_rules_with_prefix
+            dumped_reference_rules = reference_rules.dump(entities_exclude_defaults=False, by_alias=True)
+            self._write_sheets(workbook, dumped_reference_rules, reference_rules, sheet_prefix=prefix)
+            self._write_metadata_sheet(workbook, dumped_reference_rules["Metadata"], sheet_prefix=prefix)
 
         if isinstance(rules, InformationRules) and rules.prefixes:
             self._write_prefixes_sheet(workbook, rules.prefixes)

cognite/neat/_rules/exporters/_rules2instance_template.py

@@ -42,6 +42,10 @@ class InstanceTemplateExporter(BaseExporter[InformationRules, Workbook]):
         self.auto_identifier_type = auto_identifier_type
         self.add_drop_down_list = add_drop_down_list
 
+    @property
+    def description(self) -> str:
+        return "Export verified information instance template to Excel."
+
     def export(
         self,
         rules: InformationRules,

cognite/neat/_rules/exporters/_rules2ontology.py

@@ -46,6 +46,10 @@ class OWLExporter(GraphExporter):
     def export(self, rules: InformationRules) -> Graph:
         return Ontology.from_rules(rules).as_owl()
 
+    @property
+    def description(self) -> str:
+        return "Export verified information model to OWL."
+
 
 class SHACLExporter(GraphExporter):
     """Exports rules to a SHACL graph."""
@@ -53,13 +57,21 @@ class SHACLExporter(GraphExporter):
     def export(self, rules: InformationRules) -> Graph:
         return Ontology.from_rules(rules).as_shacl()
 
+    @property
+    def description(self) -> str:
+        return "Export verified information model to SHACL."
+
 
 class SemanticDataModelExporter(GraphExporter):
-    """Exports verified information rules to a semantic data model."""
+    """Exports verified information model to a semantic data model."""
 
     def export(self, rules: InformationRules) -> Graph:
         return Ontology.from_rules(rules).as_semantic_data_model()
 
+    @property
+    def description(self) -> str:
+        return "Export verified information model to a semantic data model."
+
 
 class OntologyModel(BaseModel):
     model_config: ClassVar[ConfigDict] = ConfigDict(arbitrary_types_allowed=True, strict=False, extra="allow")

cognite/neat/_rules/exporters/_rules2yaml.py

@@ -43,6 +43,10 @@ class YAMLExporter(BaseExporter[VerifiedRules, str]):
         self.files = files
         self.output = output
 
+    @property
+    def description(self) -> str:
+        return "Export verified model to YAML."
+
     def export_to_file(self, rules: VerifiedRules, filepath: Path) -> None:
         """Exports transformation rules to YAML/JSON file(s)."""
         if self.files == "single":

cognite/neat/_rules/importers/_base.py

@@ -6,6 +6,7 @@ from datetime import datetime
 from typing import TYPE_CHECKING, Any, Generic, Literal
 
 from pydantic import ValidationError
+from rdflib import URIRef
 
 from cognite.neat._constants import DEFAULT_NAMESPACE
 from cognite.neat._issues import IssueList, NeatError, NeatWarning
@@ -56,6 +57,14 @@ class BaseImporter(ABC, Generic[T_InputRules]):
 
         return ProvenanceAgent(id_=DEFAULT_NAMESPACE[f"agent/{type(self).__name__}"])
 
+    @property
+    def description(self) -> str:
+        return "MISSING DESCRIPTION"
+
+    @property
+    def source_uri(self) -> URIRef:
+        return DEFAULT_NAMESPACE["UNKNOWN"]
+
 
 class _FutureResult:
     def __init__(self) -> None: