cognite-neat 0.86.0__tar.gz → 0.87.0__tar.gz

{cognite_neat-0.86.0 → cognite_neat-0.87.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cognite-neat
-Version: 0.86.0
+Version: 0.87.0
 Summary: Knowledge graph transformation
 Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0

cognite_neat-0.87.0/cognite/neat/_version.py

@@ -0,0 +1 @@
+__version__ = "0.87.0"

{cognite_neat-0.86.0 → cognite_neat-0.87.0}/cognite/neat/constants.py

@@ -14,15 +14,17 @@ EXAMPLE_WORKFLOWS = PACKAGE_DIRECTORY / "workflows" / "examples"
 
 DEFAULT_NAMESPACE = Namespace("http://purl.org/cognite/neat#")
 
-PREFIXES = {
-    "rdf": RDF._NS,
-    "rdfs": RDFS._NS,
-    "dct": DCTERMS._NS,
-    "skos": SKOS._NS,
-    "owl": OWL._NS,
-    "xsd": XSD._NS,
-    "pav": Namespace("http://purl.org/pav/"),
-}
+
+def get_default_prefixes() -> dict[str, Namespace]:
+    return {
+        "rdf": RDF._NS,
+        "rdfs": RDFS._NS,
+        "dct": DCTERMS._NS,
+        "skos": SKOS._NS,
+        "owl": OWL._NS,
+        "xsd": XSD._NS,
+        "pav": Namespace("http://purl.org/pav/"),
+    }
 
 
 DEFAULT_URI = ""

{cognite_neat-0.86.0 → cognite_neat-0.87.0}/cognite/neat/graph/extractors/_mock_graph_generator.py

@@ -12,7 +12,7 @@ import pandas as pd
 from rdflib import RDF, Literal, Namespace, URIRef
 
 from cognite.neat.graph.models import Triple
-from cognite.neat.rules.analysis import InformationArchitectRulesAnalysis
+from cognite.neat.rules.analysis import InformationAnalysis
 from cognite.neat.rules.models import DMSRules, InformationRules
 from cognite.neat.rules.models.data_types import DataType
 from cognite.neat.rules.models.entities import ClassEntity, EntityTypes
@@ -50,8 +50,7 @@ class MockGraphGenerator(BaseExtractor):
 
         if not class_count:
             self.class_count = {
-                class_: 1
-                for class_ in InformationArchitectRulesAnalysis(self.rules).defined_classes(consider_inheritance=True)
+                class_: 1 for class_ in InformationAnalysis(self.rules).defined_classes(consider_inheritance=True)
             }
         elif all(isinstance(key, str) for key in class_count.keys()):
             self.class_count = {
@@ -101,7 +100,7 @@ def generate_triples(
     """
 
     namespace = rules.metadata.namespace
-    defined_classes = InformationArchitectRulesAnalysis(rules).defined_classes(consider_inheritance=True)
+    defined_classes = InformationAnalysis(rules).defined_classes(consider_inheritance=True)
 
     if non_existing_classes := set(class_count.keys()) - defined_classes:
         msg = f"Class count contains classes {non_existing_classes} for which properties are not defined in Data Model!"
@@ -115,16 +114,16 @@ def generate_triples(
 
     # Subset data model to only classes that are defined in class count
     rules = (
-        InformationArchitectRulesAnalysis(rules).subset_rules(set(class_count.keys()))
+        InformationAnalysis(rules).subset_rules(set(class_count.keys()))
         if defined_classes != set(class_count.keys())
         else rules
     )
 
-    class_linkage = InformationArchitectRulesAnalysis(rules).class_linkage()
+    class_linkage = InformationAnalysis(rules).class_linkage().to_pandas()
 
     # Remove one of symmetric pairs from class linkage to maintain proper linking
     # among instances of symmetrically linked classes
-    if sym_pairs := InformationArchitectRulesAnalysis(rules).symmetrically_connected_classes():
+    if sym_pairs := InformationAnalysis(rules).symmetrically_connected_classes():
         class_linkage = _remove_higher_occurring_sym_pair(class_linkage, sym_pairs)
 
     # Remove any of symmetric pairs containing classes that are not present class count
@@ -134,7 +133,7 @@ def generate_triples(
     generation_order = _prettify_generation_order(_get_generation_order(class_linkage))
 
     # Generated simple view of data model
-    class_property_pairs = InformationArchitectRulesAnalysis(rules).classes_with_properties(consider_inheritance=True)
+    class_property_pairs = InformationAnalysis(rules).classes_with_properties(consider_inheritance=True)
 
     # pregenerate instance ids for each remaining class
     instance_ids = {

{cognite_neat-0.86.0 → cognite_neat-0.87.0}/cognite/neat/graph/loaders/__init__.py

@@ -1,7 +1,8 @@
 from ._base import BaseLoader, CDFLoader
+from ._rdf2asset import AssetLoader
 from ._rdf2dms import DMSLoader
 
-__all__ = ["BaseLoader", "CDFLoader", "DMSLoader"]
+__all__ = ["BaseLoader", "CDFLoader", "DMSLoader", "AssetLoader"]
 
 
 def _repr_html_() -> str:
@@ -11,7 +12,9 @@ def _repr_html_() -> str:
         [
             {
                 "Loader": name,
-                "Description": globals()[name].__doc__.strip().split("\n")[0] if globals()[name].__doc__ else "Missing",
+                "Description": (
+                    globals()[name].__doc__.strip().split("\n")[0] if globals()[name].__doc__ else "Missing"
+                ),
             }
             for name in __all__
             if name not in ("BaseLoader", "CDFLoader")

{cognite_neat-0.86.0 → cognite_neat-0.87.0}/cognite/neat/graph/loaders/_base.py

@@ -15,6 +15,11 @@ from cognite.neat.utils.upload import UploadResult, UploadResultList
 T_Output = TypeVar("T_Output")
 
 
+# Sentinel value to indicate in the load method that all instances of a class have been loaded.
+# https://en.wikipedia.org/wiki/Sentinel_value
+class _END_OF_CLASS: ...
+
+
 class BaseLoader(ABC, Generic[T_Output]):
     _new_line = "\n"
     _encoding = "utf-8"
@@ -28,10 +33,10 @@ class BaseLoader(ABC, Generic[T_Output]):
 
     def load(self, stop_on_exception: bool = False) -> Iterable[T_Output | NeatIssue]:
         """Load the graph with data."""
-        return self._load(stop_on_exception)
+        return (item for item in self._load(stop_on_exception) if item is not _END_OF_CLASS)  # type: ignore[misc]
 
     @abstractmethod
-    def _load(self, stop_on_exception: bool = False) -> Iterable[T_Output | NeatIssue]:
+    def _load(self, stop_on_exception: bool = False) -> Iterable[T_Output | NeatIssue | type[_END_OF_CLASS]]:
         """Load the graph with data."""
         pass
 
@@ -58,13 +63,16 @@ class CDFLoader(BaseLoader[T_Output]):
 
         issues = NeatIssueList[NeatIssue]()
         items: list[T_Output] = []
-        for result in self.load(stop_on_exception=False):
+        for result in self._load(stop_on_exception=False):
             if isinstance(result, NeatIssue):
                 issues.append(result)
+            elif result is _END_OF_CLASS:
+                ...
             else:
-                items.append(result)
+                # MyPy does not understand else means the item will be of type T_Output
+                items.append(result)  # type: ignore[arg-type]
 
-            if len(items) >= self._UPLOAD_BATCH_SIZE:
+            if len(items) >= self._UPLOAD_BATCH_SIZE or result is _END_OF_CLASS:
                 yield from self._upload_to_cdf(client, items, dry_run, issues)
                 issues = NeatIssueList[NeatIssue]()
                 items = []

cognite_neat-0.87.0/cognite/neat/graph/loaders/_rdf2asset.py

@@ -0,0 +1,197 @@
+from collections import defaultdict
+from collections.abc import Iterable, Sequence
+from dataclasses import dataclass, fields
+from pathlib import Path
+
+from cognite.client import CogniteClient
+from cognite.client.data_classes import AssetWrite
+from cognite.client.data_classes.capabilities import Capability
+
+from cognite.neat.graph._tracking.base import Tracker
+from cognite.neat.graph._tracking.log import LogTracker
+from cognite.neat.graph.issues import loader as loader_issues
+from cognite.neat.graph.stores import NeatGraphStore
+from cognite.neat.issues import NeatIssue, NeatIssueList
+from cognite.neat.rules.analysis._asset import AssetAnalysis
+from cognite.neat.rules.models import AssetRules
+from cognite.neat.utils.upload import UploadResult
+
+from ._base import _END_OF_CLASS, CDFLoader
+
+
+@dataclass(frozen=True)
+class AssetLoaderMetadataKeys:
+    """Class holding mapping between NEAT metadata key names and their desired names
+    in CDF Asset metadata
+
+    Args:
+        start_time: Start time key name
+        end_time: End time key name
+        update_time: Update time key name
+        resurrection_time: Resurrection time key name
+        identifier: Identifier key name
+        active: Active key name
+        type: Type key name
+    """
+
+    start_time: str = "start_time"
+    end_time: str = "end_time"
+    update_time: str = "update_time"
+    resurrection_time: str = "resurrection_time"
+    identifier: str = "identifier"
+    active: str = "active"
+    type: str = "type"
+
+    def as_aliases(self) -> dict[str, str]:
+        return {str(field.default): getattr(self, field.name) for field in fields(self)}
+
+
+class AssetLoader(CDFLoader[AssetWrite]):
+    """Load Assets from NeatGraph to Cognite Data Fusions.
+
+    Args:
+        graph_store (NeatGraphStore): The graph store to load the data into.
+        rules (AssetRules): The rules to load the assets with.
+        data_set_id (int): The CDF data set id to load the Assets into.
+        use_orphanage (bool): Whether to use an orphanage for assets that are not part
+                              of the hierarchy. Defaults to False.
+        use_labels (bool): Whether to use labels for assets. Defaults to False.
+        asset_external_id_prefix (str | None): The prefix to use for the external id of the assets.
+                                               Defaults to None.
+        metadata_keys (AssetLoaderMetadataKeys | None): Mapping between NEAT metadata key names and
+                                                        their desired names in CDF Asset metadata. Defaults to None.
+        create_issues (Sequence[NeatIssue] | None): A list of issues that occurred during reading. Defaults to None.
+        tracker (type[Tracker] | None): The tracker to use. Defaults to None.
+    """
+
+    def __init__(
+        self,
+        graph_store: NeatGraphStore,
+        rules: AssetRules,
+        data_set_id: int,
+        use_orphanage: bool = False,
+        use_labels: bool = False,
+        asset_external_id_prefix: str | None = None,
+        metadata_keys: AssetLoaderMetadataKeys | None = None,
+        create_issues: Sequence[NeatIssue] | None = None,
+        tracker: type[Tracker] | None = None,
+    ):
+        super().__init__(graph_store)
+
+        self.rules = rules
+        self.data_set_id = data_set_id
+        self.use_labels = use_labels
+        self.use_orphanage = use_orphanage
+
+        self.orphanage_external_id = (
+            f"{asset_external_id_prefix or ''}orphanage-{data_set_id}" if use_orphanage else None
+        )
+
+        self.asset_external_id_prefix = asset_external_id_prefix
+        self.metadata_keys = metadata_keys or AssetLoaderMetadataKeys()
+
+        self._issues = NeatIssueList[NeatIssue](create_issues or [])
+        self._tracker: type[Tracker] = tracker or LogTracker
+
+    def _create_validation_classes(self) -> None:
+        # need to get back class-property pairs where are definition of
+        # asset implementations, extend InformationRulesAnalysis make it generic
+
+        # by default if there is not explicitly stated external_id
+        # use rdf:type and drop the prefix
+
+        # based on those create pydantic model AssetDefinition
+        # which will have .to_asset_write()
+
+        raise NotImplementedError("Not implemented yet, this is placeholder")
+
+    def categorize_assets(self, client: CogniteClient) -> None:
+        """Categorize assets to those to be created, updated, decommissioned, or resurrected"""
+
+        raise NotImplementedError("Not implemented yet, this is placeholder")
+
+    def _load(self, stop_on_exception: bool = False) -> Iterable[AssetWrite | NeatIssue | type[_END_OF_CLASS]]:
+        if self._issues.has_errors and stop_on_exception:
+            raise self._issues.as_exception()
+        elif self._issues.has_errors:
+            yield from self._issues
+            return
+        if not self.rules:
+            # There should already be an error in this case.
+            return
+
+        class_ids = [repr(class_.class_.id) for class_ in self.rules.classes]
+        tracker = self._tracker(type(self).__name__, class_ids, "classes")
+
+        for class_ in self.rules.classes:
+            tracker.start(repr(class_.class_.id))
+
+            property_renaming_config = AssetAnalysis(self.rules).define_property_renaming_config(class_.class_)
+
+            for identifier, properties in self.graph_store.read(class_.class_.suffix):
+                fields = _process_properties(properties, property_renaming_config)
+                # set data set id and external id
+                fields["data_set_id"] = self.data_set_id
+                fields["external_id"] = identifier
+
+                try:
+                    yield AssetWrite.load(fields)
+                except KeyError as e:
+                    error = loader_issues.InvalidInstanceError(type_="asset", identifier=identifier, reason=str(e))
+                    tracker.issue(error)
+                    if stop_on_exception:
+                        raise error.as_exception() from e
+                    yield error
+            yield _END_OF_CLASS
+
+    def load_to_cdf(self, client: CogniteClient, dry_run: bool = False) -> Sequence[AssetWrite]:
+        # generate assets
+        # check for circular asset hierarchy
+        # check for orphaned assets
+        # batch upsert of assets to CDF (otherwise we will hit the API rate limit)
+
+        raise NotImplementedError("Not implemented yet, this is placeholder")
+
+    @classmethod
+    def _check_for_circular_asset_hierarchy(cls, assets: list[AssetWrite]) -> None:
+        """Check for circular references in the asset rules"""
+        raise NotImplementedError("Not implemented yet, this is placeholder")
+
+    @classmethod
+    def _check_for_orphaned_assets(cls, assets: list[AssetWrite]) -> None:
+        """Check for circular references in the asset rules"""
+        raise NotImplementedError("Not implemented yet, this is placeholder")
+
+    def _get_required_capabilities(self) -> list[Capability]:
+        raise NotImplementedError("Not implemented yet, this is placeholder")
+
+    def _upload_to_cdf(
+        self,
+        client: CogniteClient,
+        items: list[AssetWrite],
+        dry_run: bool,
+        read_issues: NeatIssueList,
+    ) -> Iterable[UploadResult]:
+        raise NotImplementedError("Not implemented yet, this is placeholder")
+
+    def write_to_file(self, filepath: Path) -> None:
+        raise NotImplementedError("Not implemented yet, this is placeholder")
+
+
+def _process_properties(properties: dict[str, list[str]], property_renaming_config: dict[str, str]) -> dict:
+    metadata: dict[str, str] = defaultdict(str)
+    fields: dict[str, str | dict] = {}
+
+    for original_property, values in properties.items():
+        if renamed_property := property_renaming_config.get(original_property, None):
+            if renamed_property.startswith("metadata."):
+                # Asset metadata contains only string values
+                metadata[original_property] = ", ".join(values)
+            else:
+                # Asset fields can contain only one value
+                fields[renamed_property] = values[0]
+
+    if metadata:
+        fields["metadata"] = metadata
+
+    return fields

{cognite_neat-0.86.0 → cognite_neat-0.87.0}/cognite/neat/graph/loaders/_rdf2dms.py

@@ -27,7 +27,7 @@ from ._base import CDFLoader
 
 
 class DMSLoader(CDFLoader[dm.InstanceApply]):
-    """Load data from Cognite Data Fusions Data Modeling Service (DMS) into Neat.
+    """Loads Instances to Cognite Data Fusion Data Model Service from NeatGraph.
 
     Args:
         graph_store (NeatGraphStore): The graph store to load the data into.

{cognite_neat-0.86.0 → cognite_neat-0.87.0}/cognite/neat/graph/queries/_base.py

@@ -128,7 +128,7 @@ class Queries:
                 )  # type: ignore[misc, index]
 
                 if property_renaming_config:
-                    predicate = property_renaming_config.get(property_, property_)
+                    property_ = property_renaming_config.get(property_, property_)
 
                 property_values[property_].append(value)
         if property_values:

{cognite_neat-0.86.0 → cognite_neat-0.87.0}/cognite/neat/graph/queries/_construct.py

@@ -3,7 +3,7 @@ from typing import cast
 
 from rdflib import Graph, URIRef
 
-from cognite.neat.rules.analysis import InformationArchitectRulesAnalysis
+from cognite.neat.rules.analysis import InformationAnalysis
 from cognite.neat.rules.models._rdfpath import (
     AllReferences,
     Hop,
@@ -55,7 +55,7 @@ def build_construct_query(
     """
 
     if (
-        transformations := InformationArchitectRulesAnalysis(rules)
+        transformations := InformationAnalysis(rules)
         .class_property_pairs(only_rdfpath=True, consider_inheritance=True)
         .get(class_, None)
     ):

{cognite_neat-0.86.0 → cognite_neat-0.87.0}/cognite/neat/graph/queries/_shared.py

@@ -6,7 +6,7 @@ from pydantic import BaseModel, ConfigDict, Field
 from rdflib import Graph, Literal, Namespace
 from rdflib.term import URIRef
 
-from cognite.neat.constants import PREFIXES
+from cognite.neat.constants import get_default_prefixes
 from cognite.neat.rules.models._rdfpath import (
     Hop,
     Step,
@@ -37,24 +37,30 @@ class Triple(BaseModel):
         return cls(subject=triple[0], predicate=triple[1], object=triple[2])
 
 
-def generate_prefix_header(prefixes: dict[str, Namespace] = PREFIXES) -> str:
+def generate_prefix_header(prefixes: dict[str, Namespace] | None = None) -> str:
     """Generate prefix header which is added to SPARQL query and allows for shorten query statements
 
     Parameters
     ----------
     prefixes : dict
-        Dict containing prefix - namespace pairs, default PREFIXES
+        Dict containing prefix - namespace pairs, defaults to internal set of prefixes
 
     Returns
     -------
     str
         Prefix header
     """
+
+    prefixes = prefixes or get_default_prefixes()
+
     return "".join(f"PREFIX {key}:<{value}>\n" for key, value in prefixes.items())
 
 
 def get_predicate_id(
-    graph: Graph, subject_type_id: str, object_type_id: str, prefixes: dict[str, Namespace] = PREFIXES
+    graph: Graph,
+    subject_type_id: str,
+    object_type_id: str,
+    prefixes: dict[str, Namespace] | None = None,
 ) -> URIRef:
     """Returns predicate (aka property) URI (i.e., ID) that connects subject and object
 
@@ -67,13 +73,16 @@ def get_predicate_id(
     object_type_id : str
         ID of object type (aka object class)
     prefixes : dict, optional
-        Dict containing prefix - namespace pairs, default PREFIXES
+        Dict containing prefix - namespace pairs, defaults to internal set of prefixes
 
     Returns
     -------
     URIRef
         ID of predicate (aka property) connecting subject and object
     """
+
+    prefixes = prefixes or get_default_prefixes()
+
     query = """
 
         SELECT ?predicateTypeID
@@ -93,7 +102,11 @@ def get_predicate_id(
     return res[0][0]
 
 
-def hop2property_path(graph: Graph, hop: Hop, prefixes: dict[str, Namespace]) -> str:
+def hop2property_path(
+    graph: Graph,
+    hop: Hop,
+    prefixes: dict[str, Namespace] | None = None,
+) -> str:
     """Converts hop to property path string
 
     Parameters
@@ -110,6 +123,7 @@ def hop2property_path(graph: Graph, hop: Hop, prefixes: dict[str, Namespace]) ->
     str
         Property path string for hop traversal (e.g. ^rdf:type/rdfs:subClassOf)
     """
+    prefixes = prefixes if prefixes else get_default_prefixes()
 
     # setting previous step to origin, as we are starting from there
     previous_step = Step(class_=hop.class_, direction="origin")

{cognite_neat-0.86.0 → cognite_neat-0.87.0}/cognite/neat/graph/stores/_base.py

@@ -15,7 +15,7 @@ from cognite.neat.graph.extractors import RdfFileExtractor, TripleExtractors
 from cognite.neat.graph.models import Triple
 from cognite.neat.graph.queries import Queries
 from cognite.neat.graph.transformers import Transformers
-from cognite.neat.rules.analysis import InformationArchitectRulesAnalysis
+from cognite.neat.rules.analysis import InformationAnalysis
 from cognite.neat.rules.models import InformationRules
 from cognite.neat.rules.models.entities import ClassEntity
 from cognite.neat.utils.auxiliary import local_import
@@ -179,7 +179,7 @@ class NeatGraphStore:
             warnings.warn("Desired type not found in graph!", stacklevel=2)
             return None
 
-        if InformationArchitectRulesAnalysis(self.rules).has_hop_transformations():
+        if InformationAnalysis(self.rules).has_hop_transformations():
             warnings.warn(
                 "Rules contain Hop rdfpath, run ReduceHopTraversal transformer first!",
                 stacklevel=2,
@@ -188,7 +188,8 @@ class NeatGraphStore:
 
         instance_ids = self.queries.list_instances_ids_of_class(self.rules.metadata.namespace[class_])
 
-        property_renaming_config = InformationArchitectRulesAnalysis(self.rules).define_property_renaming_config()
+        property_renaming_config = InformationAnalysis(self.rules).define_property_renaming_config(class_entity)
+        print(property_renaming_config)
 
         for instance_id in instance_ids:
             yield self.queries.describe(instance_id, property_renaming_config)

{cognite_neat-0.86.0 → cognite_neat-0.87.0}/cognite/neat/legacy/graph/extractors/_dexpi.py

@@ -9,11 +9,6 @@ from cognite.neat.legacy.graph.models import Triple
 
 from ._base import BaseExtractor
 
-_DEXPI_PREFIXES = {
-    "dexpi": Namespace("http://sandbox.dexpi.org/rdl/"),
-    "posccaesar": Namespace("http://data.posccaesar.org/rdl/"),
-}
-
 
 class DexpiXML(BaseExtractor):
     """

{cognite_neat-0.86.0 → cognite_neat-0.87.0}/cognite/neat/legacy/graph/stores/_base.py

@@ -11,7 +11,7 @@ from prometheus_client import Gauge, Summary
 from rdflib import Graph, Namespace, URIRef
 from rdflib.query import Result, ResultRow
 
-from cognite.neat.constants import DEFAULT_NAMESPACE, PREFIXES
+from cognite.neat.constants import DEFAULT_NAMESPACE, get_default_prefixes
 from cognite.neat.legacy.graph.models import Triple
 from cognite.neat.legacy.graph.stores._rdf_to_graph import rdf_file_to_graph
 from cognite.neat.legacy.rules.models.rules import Rules
@@ -25,7 +25,11 @@ prom_qsm = Summary("store_query_time_summary_legacy", "Time spent processing que
 prom_sq = Gauge("store_single_query_time_legacy", "Time spent processing a single query", ["query"])
 
 MIMETypes: TypeAlias = Literal[
-    "application/rdf+xml", "text/turtle", "application/n-triple", "application/n-quads", "application/trig"
+    "application/rdf+xml",
+    "text/turtle",
+    "application/n-triple",
+    "application/n-quads",
+    "application/trig",
 ]
 
 
@@ -35,7 +39,8 @@ class NeatGraphStoreBase(ABC):
 
     Args:
         graph : Instance of rdflib.Graph class for graph storage
-        base_prefix : Used as a base prefix for graph namespace, allowing querying graph data using a shortform of a URI
+        base_prefix : Used as a base prefix for graph namespace,
+                      allowing querying graph data using a short form of a URI
         namespace : Namespace (aka URI) used to resolve any relative URI in the graph
         prefixes : Dictionary of additional prefixes used and bounded to the graph
     """
@@ -47,12 +52,12 @@ class NeatGraphStoreBase(ABC):
         graph: Graph | None = None,
         base_prefix: str = "",  # usually empty
         namespace: Namespace = DEFAULT_NAMESPACE,
-        prefixes: dict = PREFIXES,
+        prefixes: dict[str, Namespace] | None = None,
     ):
         self.graph = graph or Graph()
         self.base_prefix: str = base_prefix
         self.namespace: Namespace = namespace
-        self.prefixes: dict[str, Namespace] = prefixes
+        self.prefixes: dict[str, Namespace] = prefixes or get_default_prefixes()
 
         self.rdf_store_query_url: str | None = None
         self.rdf_store_update_url: str | None = None
@@ -164,7 +169,10 @@ class NeatGraphStoreBase(ABC):
         return None
 
     def import_from_file(
-        self, graph_file: Path, mime_type: MIMETypes = "application/rdf+xml", add_base_iri: bool = True
+        self,
+        graph_file: Path,
+        mime_type: MIMETypes = "application/rdf+xml",
+        add_base_iri: bool = True,
     ) -> None:
         """Imports graph data from file.
 
@@ -175,7 +183,10 @@ class NeatGraphStoreBase(ABC):
         """
         if add_base_iri:
             self.graph = rdf_file_to_graph(
-                self.graph, graph_file, base_namespace=self.namespace, prefixes=self.prefixes
+                self.graph,
+                graph_file,
+                base_namespace=self.namespace,
+                prefixes=self.prefixes,
             )
         else:
             self.graph = rdf_file_to_graph(self.graph, graph_file, prefixes=self.prefixes)
@@ -290,7 +301,12 @@ class NeatGraphStoreBase(ABC):
             "rdf_store_update_url": self.rdf_store_update_url,
         }
 
-    def add_triples(self, triples: list[Triple] | set[Triple], batch_size: int = 10_000, verbose: bool = False):
+    def add_triples(
+        self,
+        triples: list[Triple] | set[Triple],
+        batch_size: int = 10_000,
+        verbose: bool = False,
+    ):
         """Adds triples to the graph store in batches.
 
         Args:

{cognite_neat-0.86.0 → cognite_neat-0.87.0}/cognite/neat/legacy/graph/stores/_graphdb_store.py

@@ -4,7 +4,7 @@ import requests
 from rdflib import Graph, Namespace
 from rdflib.plugins.stores.sparqlstore import SPARQLUpdateStore
 
-from cognite.neat.constants import DEFAULT_NAMESPACE, PREFIXES
+from cognite.neat.constants import DEFAULT_NAMESPACE, get_default_prefixes
 
 from ._base import NeatGraphStoreBase
 
@@ -28,8 +28,9 @@ class GraphDBStore(NeatGraphStoreBase):
         graph: Graph | None = None,
         base_prefix: str = "",  # usually empty
         namespace: Namespace = DEFAULT_NAMESPACE,
-        prefixes: dict = PREFIXES,
+        prefixes: dict[str, Namespace] | None = None,
     ):
+        prefixes = prefixes if prefixes else get_default_prefixes()
         super().__init__(graph, base_prefix, namespace, prefixes)
         self.graph_db_rest_url: str = "http://localhost:7200"
 

{cognite_neat-0.86.0 → cognite_neat-0.87.0}/cognite/neat/legacy/graph/stores/_memory_store.py

@@ -2,7 +2,7 @@ import logging
 
 from rdflib import Graph, Namespace
 
-from cognite.neat.constants import DEFAULT_NAMESPACE, PREFIXES
+from cognite.neat.constants import DEFAULT_NAMESPACE, get_default_prefixes
 
 from ._base import NeatGraphStoreBase
 
@@ -26,9 +26,9 @@ class MemoryStore(NeatGraphStoreBase):
         graph: Graph | None = None,
         base_prefix: str = "",  # usually empty
         namespace: Namespace = DEFAULT_NAMESPACE,
-        prefixes: dict = PREFIXES,
+        prefixes: dict[str, Namespace] | None = None,
     ):
-        # Init repeated to get nice docstring
+        prefixes = prefixes if prefixes else get_default_prefixes()  # Init repeated to get nice docstring
         super().__init__(graph, base_prefix, namespace, prefixes)
 
     def _set_graph(self):