cognite-neat 0.86.0__py3-none-any.whl → 0.87.3__py3-none-any.whl

cognite/neat/graph/loaders/_rdf2asset.py

@@ -1,16 +1,25 @@
-from collections.abc import Sequence
+import json
+from collections.abc import Iterable, Sequence
 from dataclasses import dataclass, fields
+from pathlib import Path
+from typing import cast
 
+import yaml
 from cognite.client import CogniteClient
 from cognite.client.data_classes import AssetWrite
+from cognite.client.data_classes.capabilities import AssetsAcl, Capability
+from cognite.client.exceptions import CogniteAPIError
 
 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 CDFLoader
+from ._base import _END_OF_CLASS, CDFLoader
 
 
 @dataclass(frozen=True)
@@ -41,10 +50,27 @@ class AssetLoaderMetadataKeys:
 
 
 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,
-        rules: AssetRules,
         graph_store: NeatGraphStore,
+        rules: AssetRules,
         data_set_id: int,
         use_orphanage: bool = False,
         use_labels: bool = False,
@@ -58,10 +84,20 @@ class AssetLoader(CDFLoader[AssetWrite]):
         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.orphanage = (
+            AssetWrite.load(
+                {
+                    "dataSetId": self.data_set_id,
+                    "externalId": (
+                        f"{asset_external_id_prefix or ''}orphanage-{data_set_id}" if use_orphanage else None
+                    ),
+                    "name": "Orphanage",
+                    "description": "Orphanage for assets whose parents do not exist",
+                }
+            )
+            if use_orphanage
+            else None
         )
 
         self.asset_external_id_prefix = asset_external_id_prefix
@@ -70,54 +106,148 @@ class AssetLoader(CDFLoader[AssetWrite]):
         self._issues = NeatIssueList[NeatIssue](create_issues or [])
         self._tracker: type[Tracker] = tracker or LogTracker
 
-    @classmethod
-    def from_rules(
-        cls,
-        rules: AssetRules,
-        graph_store: NeatGraphStore,
-        data_set_id: int,
-        use_orphanage: bool = False,
-        use_labels: bool = False,
-        asset_external_id_prefix: str | None = None,
-        metadata_keys: AssetLoaderMetadataKeys | None = None,
-    ) -> "AssetLoader":
-        issues: list[NeatIssue] = []
-
-        return cls(
-            rules, graph_store, data_set_id, use_orphanage, use_labels, asset_external_id_prefix, metadata_keys, issues
+    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
+
+        ordered_classes = AssetAnalysis(self.rules).class_topological_sort()
+
+        tracker = self._tracker(
+            type(self).__name__,
+            [repr(class_.id) for class_ in ordered_classes],
+            "classes",
         )
 
-    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_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")
+        processed_instances = set()
+
+        if self.orphanage:
+            yield self.orphanage
+            processed_instances.add(self.orphanage.external_id)
+
+        for class_ in ordered_classes:
+            tracker.start(repr(class_.id))
+
+            property_renaming_config = AssetAnalysis(self.rules).define_property_renaming_config(class_)
+
+            for identifier, properties in self.graph_store.read(class_.suffix):
+                fields = _process_properties(properties, property_renaming_config)
+                # set data set id and external id
+                fields["dataSetId"] = self.data_set_id
+                fields["externalId"] = identifier
+
+                # check on parent
+                if "parentExternalId" in fields and fields["parentExternalId"] not in processed_instances:
+                    error = loader_issues.InvalidInstanceError(
+                        type_="asset",
+                        identifier=identifier,
+                        reason=(
+                            f"Parent asset {fields['parentExternalId']} does not exist or failed creation"
+                            f""" {
+                                f', moving the asset {identifier} under orphanage {self.orphanage.external_id}'
+                                if self.orphanage
+                                else ''}"""
+                        ),
+                    )
+                    tracker.issue(error)
+                    if stop_on_exception:
+                        raise error.as_exception()
+                    yield error
+
+                    # if orphanage is set asset will use orphanage as parent
+                    if self.orphanage:
+                        fields["parentExternalId"] = self.orphanage.external_id
+
+                    # otherwise asset will be skipped
+                    else:
+                        continue
+
+                try:
+                    yield AssetWrite.load(fields)
+                    processed_instances.add(identifier)
+                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 _get_required_capabilities(self) -> list[Capability]:
+        return [
+            AssetsAcl(
+                actions=[
+                    AssetsAcl.Action.Write,
+                    AssetsAcl.Action.Read,
+                ],
+                scope=AssetsAcl.Scope.DataSet([self.data_set_id]),
+            )
+        ]
+
+    def _upload_to_cdf(
+        self,
+        client: CogniteClient,
+        items: list[AssetWrite],
+        dry_run: bool,
+        read_issues: NeatIssueList,
+    ) -> Iterable[UploadResult]:
+        try:
+            upserted = client.assets.upsert(items, mode="replace")
+        except CogniteAPIError as e:
+            result = UploadResult[str](name="Asset", issues=read_issues)
+            result.error_messages.append(str(e))
+            result.failed_upserted.update(item.as_id() for item in e.failed + e.unknown)
+            result.upserted.update(item.as_id() for item in e.successful)
+            yield result
+        else:
+            for asset in upserted:
+                result = UploadResult[str](name="asset", issues=read_issues)
+                result.upserted.add(cast(str, asset.external_id))
+                yield result
+
+    def write_to_file(self, filepath: Path) -> None:
+        if filepath.suffix not in [".json", ".yaml", ".yml"]:
+            raise ValueError(f"File format {filepath.suffix} is not supported")
+        dumped: dict[str, list] = {"assets": []}
+        for item in self.load(stop_on_exception=False):
+            key = {
+                AssetWrite: "assets",
+                NeatIssue: "issues",
+                _END_OF_CLASS: "end_of_class",
+            }.get(type(item))
+            if key is None:
+                # This should never happen, and is a bug in neat
+                raise ValueError(f"Item {item} is not supported. This is a bug in neat please report it.")
+            if key == "end_of_class":
+                continue
+            dumped[key].append(item.dump())
+        with filepath.open("w", encoding=self._encoding, newline=self._new_line) as f:
+            if filepath.suffix == ".json":
+                json.dump(dumped, f, indent=2)
+            else:
+                yaml.safe_dump(dumped, f, sort_keys=False)
+
+
+def _process_properties(properties: dict[str, list[str]], property_renaming_config: dict[str, str]) -> dict:
+    metadata: dict[str, 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/graph/loaders/_rdf2dms.py

@@ -8,11 +8,11 @@ from cognite.client import CogniteClient
 from cognite.client import data_modeling as dm
 from cognite.client.data_classes.capabilities import Capability, DataModelInstancesAcl
 from cognite.client.data_classes.data_modeling import ViewId
+from cognite.client.data_classes.data_modeling.data_types import ListablePropertyType
 from cognite.client.data_classes.data_modeling.ids import InstanceId
 from cognite.client.data_classes.data_modeling.views import SingleEdgeConnection
 from cognite.client.exceptions import CogniteAPIError
-from pydantic import ValidationInfo, create_model, field_validator
-from pydantic.main import Model
+from pydantic import BaseModel, ValidationInfo, create_model, field_validator
 
 from cognite.neat.graph._tracking import LogTracker, Tracker
 from cognite.neat.graph.issues import loader as loader_issues
@@ -20,14 +20,14 @@ from cognite.neat.graph.stores import NeatGraphStore
 from cognite.neat.issues import NeatIssue, NeatIssueList
 from cognite.neat.rules.models import DMSRules
 from cognite.neat.rules.models.data_types import _DATA_TYPE_BY_DMS_TYPE, Json
+from cognite.neat.utils.auxiliary import create_sha256_hash
 from cognite.neat.utils.upload import UploadResult
-from cognite.neat.utils.utils import create_sha256_hash
 
 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.
@@ -140,7 +140,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
 
     def _create_validation_classes(
         self, view: dm.View
-    ) -> tuple[type[Model], dict[str, dm.EdgeConnection], NeatIssueList]:
+    ) -> tuple[type[BaseModel], dict[str, dm.EdgeConnection], NeatIssueList]:
         issues = NeatIssueList[NeatIssue]()
         field_definitions: dict[str, tuple[type, Any]] = {}
         edge_by_property: dict[str, dm.EdgeConnection] = {}
@@ -168,7 +168,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
                     if data_type == Json:
                         json_fields.append(prop_name)
                     python_type = data_type.python
-                if prop.type.is_list:
+                if isinstance(prop.type, ListablePropertyType) and prop.type.is_list:
                     python_type = list[python_type]
                 default_value: Any = prop.default_value
                 if prop.nullable:
@@ -223,7 +223,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         self,
         identifier: str,
         properties: dict[str, list[str]],
-        pydantic_cls: type[Model],
+        pydantic_cls: type[BaseModel],
         view_id: dm.ViewId,
     ) -> dm.InstanceApply:
         created = pydantic_cls.model_validate(properties)

cognite/neat/graph/queries/_base.py

@@ -8,7 +8,7 @@ from rdflib.query import ResultRow
 
 from cognite.neat.rules.models.entities import ClassEntity
 from cognite.neat.rules.models.information import InformationRules
-from cognite.neat.utils.utils import remove_namespace_from_uri
+from cognite.neat.utils.rdf_ import remove_namespace_from_uri
 
 from ._construct import build_construct_query
 
@@ -112,25 +112,34 @@ class Queries:
         property_values: dict[str, list[str]] = defaultdict(list)
 
         for subject, predicate, object_ in cast(list[ResultRow], self.graph.query(f"DESCRIBE <{instance_id}>")):
-            # We cannot include the RDF.type in case there is a neat:type property
-            # or if the object is empty
-            if predicate != RDF.type and object_.lower() not in [
+            if object_.lower() not in [
                 "",
                 "none",
                 "nan",
                 "null",
             ]:
                 # we are skipping deep validation with Pydantic to remove namespace here
-                # as it reduce time to process triples by 10-15x
-                identifier, property_, value = cast(  # type: ignore[misc]
-                    (str, str, str),
-                    remove_namespace_from_uri(*(subject, predicate, object_), validation="prefix"),
+                # as it reduces time to process triples by 10-15x
+                identifier, value = cast(  # type: ignore[misc]
+                    (str, str),
+                    remove_namespace_from_uri(*(subject, object_), validation="prefix"),
                 )  # type: ignore[misc, index]
 
-                if property_renaming_config:
-                    predicate = property_renaming_config.get(property_, property_)
+                # use-case: calling describe without renaming properties
+                # losing the namespace from the predicate!
+                if not property_renaming_config and predicate != RDF.type:
+                    property_values[remove_namespace_from_uri(predicate, validation="prefix")].append(value)
+
+                # use-case: calling describe with renaming properties
+                # renaming the property to the new name, if the property is defined
+                # in the RULES sheet
+                elif property_renaming_config and (property_ := property_renaming_config.get(predicate, None)):
+                    property_values[property_].append(value)
+
+                # use-case: skip the property if it is not defined in property_renaming_config
+                else:
+                    continue
 
-                property_values[property_].append(value)
         if property_values:
             return (
                 identifier,

cognite/neat/graph/queries/_construct.py

@@ -3,17 +3,17 @@ 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,
     RDFPath,
+    SelfReferenceProperty,
     SingleProperty,
     Traversal,
 )
 from cognite.neat.rules.models.entities import ClassEntity
 from cognite.neat.rules.models.information import InformationProperty, InformationRules
-from cognite.neat.utils.utils import most_occurring_element
+from cognite.neat.utils.collection_ import most_occurring_element
 
 from ._shared import Triple, hop2property_path
 
@@ -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)
     ):
@@ -121,7 +121,7 @@ def to_construct_triples(
         templates.append(graph_template_triple)
 
         # use case AllReferences: binding instance to certain rdf property
-        if isinstance(traversal, AllReferences):
+        if isinstance(traversal, SelfReferenceProperty):
             graph_pattern_triple = Triple(
                 subject="BIND(?instance",
                 predicate="AS",

cognite/neat/graph/queries/_shared.py

@@ -6,12 +6,12 @@ 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,
 )
-from cognite.neat.utils.utils import remove_namespace_from_uri, uri_to_short_form
+from cognite.neat.utils.rdf_ import remove_namespace_from_uri, uri_to_short_form
 
 if sys.version_info >= (3, 11):
     from typing import Self
@@ -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/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,16 +179,28 @@ class NeatGraphStore:
             warnings.warn("Desired type not found in graph!", stacklevel=2)
             return None
 
-        if InformationArchitectRulesAnalysis(self.rules).has_hop_transformations():
+        analysis = InformationAnalysis(self.rules)
+        has_hop_transformations = analysis.has_hop_transformations()
+        has_self_reference_transformations = analysis.has_self_reference_property_transformations()
+        if has_hop_transformations or has_self_reference_transformations:
+            msg = (
+                f"Rules contain [{'Hop' if has_hop_transformations else '' }"
+                f", {'SelfReferenceProperty' if has_self_reference_transformations else '' }]"
+                " rdfpath."
+                f" Run [{'ReduceHopTraversal' if has_hop_transformations else '' }"
+                f", {'AddSelfReferenceProperty' if has_self_reference_transformations else '' }]"
+                " transformer(s) first!"
+            )
+
             warnings.warn(
-                "Rules contain Hop rdfpath, run ReduceHopTraversal transformer first!",
+                msg,
                 stacklevel=2,
             )
             return None
 
         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)
 
         for instance_id in instance_ids:
             yield self.queries.describe(instance_id, property_renaming_config)

cognite/neat/graph/transformers/__init__.py

@@ -6,6 +6,7 @@ from ._classic_cdf import (
     AssetSequenceConnector,
     AssetTimeSeriesConnector,
 )
+from ._rdfpath import AddSelfReferenceProperty
 
 __all__ = [
     "AddAssetDepth",
@@ -14,6 +15,7 @@ __all__ = [
     "AssetFileConnector",
     "AssetEventConnector",
     "AssetRelationshipConnector",
+    "AddSelfReferenceProperty",
 ]
 
 Transformers = (
@@ -23,4 +25,5 @@ Transformers = (
     | AssetFileConnector
     | AssetEventConnector
     | AssetRelationshipConnector
+    | AddSelfReferenceProperty
 )

cognite/neat/graph/transformers/_rdfpath.py

@@ -1,3 +1,9 @@
+from rdflib import RDF, Graph
+
+from cognite.neat.rules.analysis import InformationAnalysis
+from cognite.neat.rules.models._rdfpath import RDFPath, SingleProperty
+from cognite.neat.rules.models.information import InformationRules
+
 from ._base import BaseTransformer
 
 
@@ -5,3 +11,39 @@ class ReduceHopTraversal(BaseTransformer):
     """ReduceHopTraversal is a transformer that reduces the number of hops to direct connection."""
 
     ...
+
+
+class AddSelfReferenceProperty(BaseTransformer):
+    description: str = "Adds property that contains id of reference to all references of given class in Rules"
+    _use_only_once: bool = True
+    _need_changes = frozenset({})
+
+    def __init__(
+        self,
+        rules: InformationRules,
+    ):
+        self.rules = rules
+        self.properties = InformationAnalysis(rules).all_reference_transformations()
+
+    def transform(self, graph: Graph) -> None:
+        for property_ in self.properties:
+            prefix = property_.transformation.traversal.class_.prefix
+            suffix = property_.transformation.traversal.class_.suffix
+
+            namespace = self.rules.prefixes[prefix] if prefix in self.rules.prefixes else self.rules.metadata.namespace
+
+            for reference in graph.subjects(RDF.type, namespace[suffix]):
+                graph.add(
+                    (
+                        reference,
+                        self.rules.metadata.namespace[property_.property_],
+                        reference,
+                    )
+                )
+
+            traversal = SingleProperty.from_string(
+                class_=property_.class_.id,
+                property_=f"{self.rules.metadata.prefix}:{property_.property_}",
+            )
+
+            property_.transformation = RDFPath(traversal=traversal)

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/legacy/graph/extractors/_mock_graph_generator.py

@@ -20,7 +20,7 @@ from cognite.neat.legacy.rules.analysis import (
 from cognite.neat.legacy.rules.exporters._rules2rules import subset_rules
 from cognite.neat.legacy.rules.models import Rules
 from cognite.neat.legacy.rules.models.value_types import XSD_VALUE_TYPE_MAPPINGS
-from cognite.neat.utils.utils import remove_namespace_from_uri
+from cognite.neat.utils.rdf_ import remove_namespace_from_uri
 
 from ._base import BaseExtractor
 

cognite/neat/legacy/graph/loaders/_asset_loader.py

@@ -15,8 +15,8 @@ from rdflib.query import ResultRow
 from cognite.neat.legacy.graph.stores import NeatGraphStoreBase
 from cognite.neat.legacy.rules.models import Rules
 from cognite.neat.legacy.rules.models.rules import Property
-from cognite.neat.utils import remove_namespace_from_uri
-from cognite.neat.utils.utils import epoch_now_ms
+from cognite.neat.utils.rdf_ import remove_namespace_from_uri
+from cognite.neat.utils.time_ import epoch_now_ms
 
 from ._base import CogniteLoader