cognite-neat 0.85.7__py3-none-any.whl → 0.85.8__py3-none-any.whl

cognite/neat/_version.py

@@ -1 +1 @@
-__version__ = "0.85.7"
+__version__ = "0.85.8"

cognite/neat/graph/extractors/_classic_cdf/_assets.py

@@ -1,10 +1,12 @@
+import json
+import re
 from collections.abc import Callable, Iterable
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import cast
 
 from cognite.client import CogniteClient
-from cognite.client.data_classes import Asset, AssetList
+from cognite.client.data_classes import Asset, AssetFilter, AssetList
 from rdflib import RDF, Literal, Namespace
 
 from cognite.neat.constants import DEFAULT_NAMESPACE
@@ -21,17 +23,32 @@ class AssetsExtractor(BaseExtractor):
         namespace (Namespace, optional): The namespace to use. Defaults to DEFAULT_NAMESPACE.
         to_type (Callable[[Asset], str | None], optional): A function to convert an asset to a type. Defaults to None.
             If None or if the function returns None, the asset will be set to the default type "Asset".
+        total (int, optional): The total number of assets to load. If passed, you will get a progress bar if rich
+            is installed. Defaults to None.
+        limit (int, optional): The maximal number of assets to load. Defaults to None. This is typically used for
+            testing setup of the extractor. For example, if you are extracting 100 000 assets, you might want to
+            limit the extraction to 1000 assets to test the setup.
+        unpack_metadata (bool, optional): Whether to unpack metadata. Defaults to False, which yields the metadata as
+            a JSON string.
     """
 
+    _SPACE_PATTERN = re.compile(r"\s+")
+
     def __init__(
         self,
         assets: Iterable[Asset],
         namespace: Namespace | None = None,
         to_type: Callable[[Asset], str | None] | None = None,
+        total: int | None = None,
+        limit: int | None = None,
+        unpack_metadata: bool = False,
     ):
         self.namespace = namespace or DEFAULT_NAMESPACE
         self.assets = assets
         self.to_type = to_type
+        self.total = total
+        self.limit = min(limit, total) if limit and total else limit
+        self.unpack_metadata = unpack_metadata
 
     @classmethod
     def from_dataset(
@@ -40,8 +57,22 @@ class AssetsExtractor(BaseExtractor):
         data_set_external_id: str,
         namespace: Namespace | None = None,
         to_type: Callable[[Asset], str | None] | None = None,
+        limit: int | None = None,
+        unpack_metadata: bool = False,
     ):
-        return cls(cast(Iterable[Asset], client.assets(data_set_external_ids=data_set_external_id)), namespace, to_type)
+        total = client.assets.aggregate_count(filter=AssetFilter(data_set_ids=[{"externalId": data_set_external_id}]))
+
+        return cls(
+            cast(
+                Iterable[Asset],
+                client.assets(data_set_external_ids=data_set_external_id),
+            ),
+            namespace,
+            to_type,
+            total,
+            limit,
+            unpack_metadata=unpack_metadata,
+        )
 
     @classmethod
     def from_hierarchy(
@@ -50,57 +81,99 @@ class AssetsExtractor(BaseExtractor):
         root_asset_external_id: str,
         namespace: Namespace | None = None,
         to_type: Callable[[Asset], str | None] | None = None,
+        limit: int | None = None,
+        unpack_metadata: bool = False,
     ):
+        total = client.assets.aggregate_count(
+            filter=AssetFilter(asset_subtree_ids=[{"externalId": root_asset_external_id}])
+        )
+
         return cls(
-            cast(Iterable[Asset], client.assets(asset_subtree_external_ids=root_asset_external_id)), namespace, to_type
+            cast(
+                Iterable[Asset],
+                client.assets(asset_subtree_external_ids=root_asset_external_id),
+            ),
+            namespace,
+            to_type,
+            total,
+            limit,
+            unpack_metadata=unpack_metadata,
         )
 
     @classmethod
     def from_file(
-        cls, file_path: str, namespace: Namespace | None = None, to_type: Callable[[Asset], str] | None = None
+        cls,
+        file_path: str,
+        namespace: Namespace | None = None,
+        to_type: Callable[[Asset], str] | None = None,
+        limit: int | None = None,
+        unpack_metadata: bool = False,
     ):
-        return cls(AssetList.load(Path(file_path).read_text()), namespace, to_type)
+        return cls(
+            AssetList.load(Path(file_path).read_text()),
+            namespace,
+            to_type,
+            limit,
+            unpack_metadata=unpack_metadata,
+        )
 
     def extract(self) -> Iterable[Triple]:
         """Extracts an asset with the given asset_id."""
-        for asset in self.assets:
-            yield from self._asset2triples(asset, self.namespace)
-
-    def _asset2triples(self, asset: Asset, namespace: Namespace) -> list[Triple]:
+        if self.total:
+            try:
+                from rich.progress import track
+            except ModuleNotFoundError:
+                to_iterate = self.assets
+            else:
+                to_iterate = track(
+                    self.assets,
+                    total=self.limit or self.total,
+                    description="Extracting Assets",
+                )
+        else:
+            to_iterate = self.assets
+        for no, asset in enumerate(to_iterate):
+            yield from self._asset2triples(asset)
+            if self.limit and no >= self.limit:
+                break
+
+    def _asset2triples(self, asset: Asset) -> list[Triple]:
         """Converts an asset to triples."""
-        id_ = namespace[f"Asset_{asset.id}"]
+        id_ = self.namespace[f"Asset_{asset.id}"]
 
         # Set rdf type
         type_ = "Asset"
         if self.to_type:
             type_ = self.to_type(asset) or type_
-        triples: list[Triple] = [(id_, RDF.type, namespace[type_])]
+        type_ = self._SPACE_PATTERN.sub("_", type_)
+
+        triples: list[Triple] = [(id_, RDF.type, self.namespace[type_])]
 
         # Create attributes
         if asset.name:
-            triples.append((id_, namespace.name, Literal(asset.name)))
+            triples.append((id_, self.namespace.name, Literal(asset.name)))
 
         if asset.description:
-            triples.append((id_, namespace.description, Literal(asset.description)))
+            triples.append((id_, self.namespace.description, Literal(asset.description)))
 
         if asset.external_id:
-            triples.append((id_, namespace.external_id, Literal(asset.external_id)))
+            triples.append((id_, self.namespace.external_id, Literal(asset.external_id)))
 
         if asset.source:
-            triples.append((id_, namespace.source, Literal(asset.source)))
+            triples.append((id_, self.namespace.source, Literal(asset.source)))
 
         # properties ref creation and update
         triples.append(
             (
                 id_,
-                namespace.created_time,
+                self.namespace.created_time,
                 Literal(datetime.fromtimestamp(asset.created_time / 1000, timezone.utc)),
             )
         )
         triples.append(
             (
                 id_,
-                namespace.last_updated_time,
+                self.namespace.last_updated_time,
                 Literal(datetime.fromtimestamp(asset.last_updated_time / 1000, timezone.utc)),
             )
         )
@@ -110,22 +183,41 @@ class AssetsExtractor(BaseExtractor):
                 # external_id can create ill-formed URIs, so we create websafe URIs
                 # since labels do not have internal ids, we use the external_id as the id
                 triples.append(
-                    (id_, namespace.label, namespace[f"Label_{create_sha256_hash(label.dump()['externalId'])}"])
+                    (
+                        id_,
+                        self.namespace.label,
+                        self.namespace[f"Label_{create_sha256_hash(label.dump()['externalId'])}"],
+                    )
                 )
 
         if asset.metadata:
-            for key, value in asset.metadata.items():
-                if value:
-                    triples.append((id_, namespace[key], Literal(string_to_ideal_type(value))))
+            if self.unpack_metadata:
+                for key, value in asset.metadata.items():
+                    if value:
+                        triples.append(
+                            (
+                                id_,
+                                self.namespace[key],
+                                Literal(string_to_ideal_type(value)),
+                            )
+                        )
+            else:
+                triples.append((id_, self.namespace.metadata, Literal(json.dumps(asset.metadata))))
 
         # Create connections:
         if asset.parent_id:
-            triples.append((id_, namespace.parent, namespace[f"Asset_{asset.parent_id}"]))
+            triples.append((id_, self.namespace.parent, self.namespace[f"Asset_{asset.parent_id}"]))
 
         if asset.root_id:
-            triples.append((id_, namespace.root, namespace[f"Asset_{asset.root_id}"]))
+            triples.append((id_, self.namespace.root, self.namespace[f"Asset_{asset.root_id}"]))
 
         if asset.data_set_id:
-            triples.append((id_, namespace.dataset, namespace[f"Dataset_{asset.data_set_id}"]))
+            triples.append(
+                (
+                    id_,
+                    self.namespace.dataset,
+                    self.namespace[f"Dataset_{asset.data_set_id}"],
+                )
+            )
 
         return triples

cognite/neat/graph/extractors/_classic_cdf/_events.py

@@ -1,3 +1,4 @@
+import json
 from collections.abc import Iterable
 from datetime import datetime, timezone
 from pathlib import Path
@@ -20,15 +21,19 @@ class EventsExtractor(BaseExtractor):
     Args:
         events (Iterable[Event]): An iterable of events.
         namespace (Namespace, optional): The namespace to use. Defaults to DEFAULT_NAMESPACE.
+        unpack_metadata (bool, optional): Whether to unpack metadata. Defaults to False, which yields the metadata as
+            a JSON string.
     """
 
     def __init__(
         self,
         events: Iterable[Event],
         namespace: Namespace | None = None,
+        unpack_metadata: bool = False,
     ):
         self.namespace = namespace or DEFAULT_NAMESPACE
         self.events = events
+        self.unpack_metadata = unpack_metadata
 
     @classmethod
     def from_dataset(
@@ -36,61 +41,80 @@ class EventsExtractor(BaseExtractor):
         client: CogniteClient,
         data_set_external_id: str,
         namespace: Namespace | None = None,
+        unpack_metadata: bool = False,
     ):
-        return cls(cast(Iterable[Event], client.events(data_set_external_ids=data_set_external_id)), namespace)
+        return cls(
+            cast(
+                Iterable[Event],
+                client.events(data_set_external_ids=data_set_external_id),
+            ),
+            namespace,
+            unpack_metadata,
+        )
 
     @classmethod
-    def from_file(cls, file_path: str, namespace: Namespace | None = None):
-        return cls(EventList.load(Path(file_path).read_text()), namespace)
+    def from_file(
+        cls,
+        file_path: str,
+        namespace: Namespace | None = None,
+        unpack_metadata: bool = False,
+    ):
+        return cls(EventList.load(Path(file_path).read_text()), namespace, unpack_metadata)
 
     def extract(self) -> Iterable[Triple]:
         """Extract events as triples."""
         for event in self.events:
-            yield from self._event2triples(event, self.namespace)
+            yield from self._event2triples(event)
 
-    @classmethod
-    def _event2triples(cls, event: Event, namespace: Namespace) -> list[Triple]:
-        id_ = namespace[f"Event_{event.id}"]
+    def _event2triples(self, event: Event) -> list[Triple]:
+        id_ = self.namespace[f"Event_{event.id}"]
 
         # Set rdf type
-        triples: list[Triple] = [(id_, RDF.type, namespace.Event)]
+        triples: list[Triple] = [(id_, RDF.type, self.namespace.Event)]
 
         # Create attributes
 
         if event.external_id:
-            triples.append((id_, namespace.external_id, Literal(event.external_id)))
+            triples.append((id_, self.namespace.external_id, Literal(event.external_id)))
 
         if event.source:
-            triples.append((id_, namespace.type, Literal(event.source)))
+            triples.append((id_, self.namespace.type, Literal(event.source)))
 
         if event.type:
-            triples.append((id_, namespace.type, Literal(event.type)))
+            triples.append((id_, self.namespace.type, Literal(event.type)))
 
         if event.subtype:
-            triples.append((id_, namespace.subtype, Literal(event.subtype)))
+            triples.append((id_, self.namespace.subtype, Literal(event.subtype)))
 
         if event.metadata:
-            for key, value in event.metadata.items():
-                if value:
-                    type_aware_value = string_to_ideal_type(value)
-                    try:
-                        triples.append((id_, namespace[key], URIRef(str(AnyHttpUrl(type_aware_value)))))  # type: ignore
-                    except ValidationError:
-                        triples.append((id_, namespace[key], Literal(type_aware_value)))
+            if self.unpack_metadata:
+                for key, value in event.metadata.items():
+                    if value:
+                        type_aware_value = string_to_ideal_type(value)
+                        try:
+                            triples.append((id_, self.namespace[key], URIRef(str(AnyHttpUrl(type_aware_value)))))  # type: ignore
+                        except ValidationError:
+                            triples.append((id_, self.namespace[key], Literal(type_aware_value)))
+            else:
+                triples.append((id_, self.namespace.metadata, Literal(json.dumps(event.metadata))))
 
         if event.description:
-            triples.append((id_, namespace.description, Literal(event.description)))
+            triples.append((id_, self.namespace.description, Literal(event.description)))
 
         if event.created_time:
             triples.append(
-                (id_, namespace.created_time, Literal(datetime.fromtimestamp(event.created_time / 1000, timezone.utc)))
+                (
+                    id_,
+                    self.namespace.created_time,
+                    Literal(datetime.fromtimestamp(event.created_time / 1000, timezone.utc)),
+                )
             )
 
         if event.last_updated_time:
             triples.append(
                 (
                     id_,
-                    namespace.last_updated_time,
+                    self.namespace.last_updated_time,
                     Literal(datetime.fromtimestamp(event.last_updated_time / 1000, timezone.utc)),
                 )
             )
@@ -99,7 +123,7 @@ class EventsExtractor(BaseExtractor):
             triples.append(
                 (
                     id_,
-                    namespace.start_time,
+                    self.namespace.start_time,
                     Literal(datetime.fromtimestamp(event.start_time / 1000, timezone.utc)),
                 )
             )
@@ -108,16 +132,22 @@ class EventsExtractor(BaseExtractor):
             triples.append(
                 (
                     id_,
-                    namespace.end_time,
+                    self.namespace.end_time,
                     Literal(datetime.fromtimestamp(event.end_time / 1000, timezone.utc)),
                 )
             )
 
         if event.data_set_id:
-            triples.append((id_, namespace.data_set_id, namespace[f"Dataset_{event.data_set_id}"]))
+            triples.append(
+                (
+                    id_,
+                    self.namespace.data_set_id,
+                    self.namespace[f"Dataset_{event.data_set_id}"],
+                )
+            )
 
         if event.asset_ids:
             for asset_id in event.asset_ids:
-                triples.append((id_, namespace.asset, namespace[f"Asset_{asset_id}"]))
+                triples.append((id_, self.namespace.asset, self.namespace[f"Asset_{asset_id}"]))
 
         return triples

cognite/neat/graph/extractors/_classic_cdf/_files.py

@@ -1,3 +1,4 @@
+import json
 from collections.abc import Iterable
 from datetime import datetime, timezone
 from pathlib import Path
@@ -21,15 +22,19 @@ class FilesExtractor(BaseExtractor):
     Args:
         files_metadata (Iterable[FileMetadata]): An iterable of files metadata.
         namespace (Namespace, optional): The namespace to use. Defaults to DEFAULT_NAMESPACE.
+        unpack_metadata (bool, optional): Whether to unpack metadata. Defaults to False, which yields the metadata as
+            a JSON string.
     """
 
     def __init__(
         self,
         files_metadata: Iterable[FileMetadata],
         namespace: Namespace | None = None,
+        unpack_metadata: bool = False,
     ):
         self.namespace = namespace or DEFAULT_NAMESPACE
         self.files_metadata = files_metadata
+        self.unpack_metadata = unpack_metadata
 
     @classmethod
     def from_dataset(
@@ -37,56 +42,75 @@ class FilesExtractor(BaseExtractor):
         client: CogniteClient,
         data_set_external_id: str,
         namespace: Namespace | None = None,
+        unpack_metadata: bool = False,
     ):
-        return cls(cast(Iterable[FileMetadata], client.files(data_set_external_ids=data_set_external_id)), namespace)
+        return cls(
+            cast(
+                Iterable[FileMetadata],
+                client.files(data_set_external_ids=data_set_external_id),
+            ),
+            namespace,
+            unpack_metadata,
+        )
 
     @classmethod
-    def from_file(cls, file_path: str, namespace: Namespace | None = None):
-        return cls(FileMetadataList.load(Path(file_path).read_text()), namespace)
+    def from_file(
+        cls,
+        file_path: str,
+        namespace: Namespace | None = None,
+        unpack_metadata: bool = False,
+    ):
+        return cls(
+            FileMetadataList.load(Path(file_path).read_text()),
+            namespace,
+            unpack_metadata,
+        )
 
     def extract(self) -> Iterable[Triple]:
         """Extract files metadata as triples."""
         for event in self.files_metadata:
-            yield from self._file2triples(event, self.namespace)
+            yield from self._file2triples(event)
 
-    @classmethod
-    def _file2triples(cls, file: FileMetadata, namespace: Namespace) -> list[Triple]:
-        id_ = namespace[f"File_{file.id}"]
+    def _file2triples(self, file: FileMetadata) -> list[Triple]:
+        id_ = self.namespace[f"File_{file.id}"]
 
         # Set rdf type
-        triples: list[Triple] = [(id_, RDF.type, namespace.File)]
+        triples: list[Triple] = [(id_, RDF.type, self.namespace.File)]
 
         # Create attributes
 
         if file.external_id:
-            triples.append((id_, namespace.external_id, Literal(file.external_id)))
+            triples.append((id_, self.namespace.external_id, Literal(file.external_id)))
 
         if file.source:
-            triples.append((id_, namespace.type, Literal(file.source)))
+            triples.append((id_, self.namespace.type, Literal(file.source)))
 
         if file.mime_type:
-            triples.append((id_, namespace.mime_type, Literal(file.mime_type)))
+            triples.append((id_, self.namespace.mime_type, Literal(file.mime_type)))
 
         if file.uploaded:
-            triples.append((id_, namespace.uploaded, Literal(file.uploaded)))
+            triples.append((id_, self.namespace.uploaded, Literal(file.uploaded)))
 
         if file.source:
-            triples.append((id_, namespace.source, Literal(file.source)))
+            triples.append((id_, self.namespace.source, Literal(file.source)))
 
         if file.metadata:
-            for key, value in file.metadata.items():
-                if value:
-                    type_aware_value = string_to_ideal_type(value)
-                    try:
-                        triples.append((id_, namespace[key], URIRef(str(AnyHttpUrl(type_aware_value)))))  # type: ignore
-                    except ValidationError:
-                        triples.append((id_, namespace[key], Literal(type_aware_value)))
+            if self.unpack_metadata:
+                for key, value in file.metadata.items():
+                    if value:
+                        type_aware_value = string_to_ideal_type(value)
+                        try:
+                            triples.append((id_, self.namespace[key], URIRef(str(AnyHttpUrl(type_aware_value)))))  # type: ignore
+                        except ValidationError:
+                            triples.append((id_, self.namespace[key], Literal(type_aware_value)))
+            else:
+                triples.append((id_, self.namespace.metadata, Literal(json.dumps(file.metadata))))
 
         if file.source_created_time:
             triples.append(
                 (
                     id_,
-                    namespace.source_created_time,
+                    self.namespace.source_created_time,
                     Literal(datetime.fromtimestamp(file.source_created_time / 1000, timezone.utc)),
                 )
             )
@@ -94,25 +118,33 @@ class FilesExtractor(BaseExtractor):
             triples.append(
                 (
                     id_,
-                    namespace.source_created_time,
+                    self.namespace.source_created_time,
                     Literal(datetime.fromtimestamp(file.source_modified_time / 1000, timezone.utc)),
                 )
             )
         if file.uploaded_time:
             triples.append(
-                (id_, namespace.uploaded_time, Literal(datetime.fromtimestamp(file.uploaded_time / 1000, timezone.utc)))
+                (
+                    id_,
+                    self.namespace.uploaded_time,
+                    Literal(datetime.fromtimestamp(file.uploaded_time / 1000, timezone.utc)),
+                )
             )
 
         if file.created_time:
             triples.append(
-                (id_, namespace.created_time, Literal(datetime.fromtimestamp(file.created_time / 1000, timezone.utc)))
+                (
+                    id_,
+                    self.namespace.created_time,
+                    Literal(datetime.fromtimestamp(file.created_time / 1000, timezone.utc)),
+                )
             )
 
         if file.last_updated_time:
             triples.append(
                 (
                     id_,
-                    namespace.last_updated_time,
+                    self.namespace.last_updated_time,
                     Literal(datetime.fromtimestamp(file.last_updated_time / 1000, timezone.utc)),
                 )
             )
@@ -121,17 +153,29 @@ class FilesExtractor(BaseExtractor):
             for label in file.labels:
                 # external_id can create ill-formed URIs, so we create websafe URIs
                 # since labels do not have internal ids, we use the external_id as the id
-                triples.append((id_, namespace.label, namespace[f"Label_{quote(label.dump()['externalId'])}"]))
+                triples.append(
+                    (
+                        id_,
+                        self.namespace.label,
+                        self.namespace[f"Label_{quote(label.dump()['externalId'])}"],
+                    )
+                )
 
         if file.security_categories:
             for category in file.security_categories:
-                triples.append((id_, namespace.security_categories, Literal(category)))
+                triples.append((id_, self.namespace.security_categories, Literal(category)))
 
         if file.data_set_id:
-            triples.append((id_, namespace.data_set_id, namespace[f"Dataset_{file.data_set_id}"]))
+            triples.append(
+                (
+                    id_,
+                    self.namespace.data_set_id,
+                    self.namespace[f"Dataset_{file.data_set_id}"],
+                )
+            )
 
         if file.asset_ids:
             for asset_id in file.asset_ids:
-                triples.append((id_, namespace.asset, namespace[f"Asset_{asset_id}"]))
+                triples.append((id_, self.namespace.asset, self.namespace[f"Asset_{asset_id}"]))
 
         return triples

cognite/neat/graph/extractors/_classic_cdf/_labels.py

@@ -37,7 +37,11 @@ class LabelsExtractor(BaseExtractor):
         namespace: Namespace | None = None,
     ):
         return cls(
-            cast(Iterable[LabelDefinition], client.labels(data_set_external_ids=data_set_external_id)), namespace
+            cast(
+                Iterable[LabelDefinition],
+                client.labels(data_set_external_ids=data_set_external_id),
+            ),
+            namespace,
         )
 
     @classmethod
@@ -47,36 +51,41 @@ class LabelsExtractor(BaseExtractor):
     def extract(self) -> Iterable[Triple]:
         """Extract labels as triples."""
         for label in self.labels:
-            yield from self._labels2triples(label, self.namespace)
+            yield from self._labels2triples(label)
 
-    @classmethod
-    def _labels2triples(cls, label: LabelDefinition, namespace: Namespace) -> list[Triple]:
+    def _labels2triples(self, label: LabelDefinition) -> list[Triple]:
         if label.external_id:
-            id_ = namespace[f"Label_{create_sha256_hash(label.external_id)}"]
+            id_ = self.namespace[f"Label_{create_sha256_hash(label.external_id)}"]
 
             # Set rdf type
-            triples: list[Triple] = [(id_, RDF.type, namespace.Label)]
+            triples: list[Triple] = [(id_, RDF.type, self.namespace.Label)]
 
             # Create attributes
-            triples.append((id_, namespace.external_id, Literal(label.external_id)))
+            triples.append((id_, self.namespace.external_id, Literal(label.external_id)))
 
             if label.name:
-                triples.append((id_, namespace.name, Literal(label.name)))
+                triples.append((id_, self.namespace.name, Literal(label.name)))
 
             if label.description:
-                triples.append((id_, namespace.description, Literal(label.description)))
+                triples.append((id_, self.namespace.description, Literal(label.description)))
 
             if label.created_time:
                 triples.append(
                     (
                         id_,
-                        namespace.created_time,
+                        self.namespace.created_time,
                         Literal(datetime.fromtimestamp(label.created_time / 1000, timezone.utc)),
                     )
                 )
 
             if label.data_set_id:
-                triples.append((id_, namespace.data_set_id, namespace[f"Dataset_{label.data_set_id}"]))
+                triples.append(
+                    (
+                        id_,
+                        self.namespace.data_set_id,
+                        self.namespace[f"Dataset_{label.data_set_id}"],
+                    )
+                )
 
             return triples
         return []

cognite/neat/graph/extractors/_classic_cdf/_relationships.py

@@ -38,7 +38,11 @@ class RelationshipsExtractor(BaseExtractor):
         namespace: Namespace | None = None,
     ):
         return cls(
-            cast(Iterable[Relationship], client.relationships(data_set_external_ids=data_set_external_id)), namespace
+            cast(
+                Iterable[Relationship],
+                client.relationships(data_set_external_ids=data_set_external_id),
+            ),
+            namespace,
         )
 
     @classmethod
@@ -48,26 +52,25 @@ class RelationshipsExtractor(BaseExtractor):
     def extract(self) -> Iterable[Triple]:
         """Extracts an asset with the given asset_id."""
         for relationship in self.relationships:
-            yield from self._relationship2triples(relationship, self.namespace)
+            yield from self._relationship2triples(relationship)
 
-    @classmethod
-    def _relationship2triples(cls, relationship: Relationship, namespace: Namespace) -> list[Triple]:
+    def _relationship2triples(self, relationship: Relationship) -> list[Triple]:
         """Converts an asset to triples."""
 
         if relationship.external_id and relationship.source_external_id and relationship.target_external_id:
             # relationships do not have an internal id, so we generate one
-            id_ = namespace[f"Relationship_{create_sha256_hash(relationship.external_id)}"]
+            id_ = self.namespace[f"Relationship_{create_sha256_hash(relationship.external_id)}"]
 
             # Set rdf type
-            triples: list[Triple] = [(id_, RDF.type, namespace["Relationship"])]
+            triples: list[Triple] = [(id_, RDF.type, self.namespace["Relationship"])]
 
             # Set source and target types
             if source_type := relationship.source_type:
                 triples.append(
                     (
                         id_,
-                        namespace.source_type,
-                        namespace[source_type.title()],
+                        self.namespace.source_type,
+                        self.namespace[source_type.title()],
                     )
                 )
 
@@ -75,19 +78,19 @@ class RelationshipsExtractor(BaseExtractor):
                 triples.append(
                     (
                         id_,
-                        namespace.target_type,
-                        namespace[target_type.title()],
+                        self.namespace.target_type,
+                        self.namespace[target_type.title()],
                     )
                 )
 
             # Create attributes
 
-            triples.append((id_, namespace.external_id, Literal(relationship.external_id)))
+            triples.append((id_, self.namespace.external_id, Literal(relationship.external_id)))
 
             triples.append(
                 (
                     id_,
-                    namespace.source_external_id,
+                    self.namespace.source_external_id,
                     Literal(relationship.source_external_id),
                 )
             )
@@ -95,7 +98,7 @@ class RelationshipsExtractor(BaseExtractor):
             triples.append(
                 (
                     id_,
-                    namespace.target_external_id,
+                    self.namespace.target_external_id,
                     Literal(relationship.target_external_id),
                 )
             )
@@ -104,7 +107,7 @@ class RelationshipsExtractor(BaseExtractor):
                 triples.append(
                     (
                         id_,
-                        namespace.start_time,
+                        self.namespace.start_time,
                         Literal(datetime.fromtimestamp(relationship.start_time / 1000, timezone.utc)),
                     )
                 )
@@ -113,7 +116,7 @@ class RelationshipsExtractor(BaseExtractor):
                 triples.append(
                     (
                         id_,
-                        namespace.end_time,
+                        self.namespace.end_time,
                         Literal(datetime.fromtimestamp(relationship.end_time / 1000, timezone.utc)),
                     )
                 )
@@ -122,7 +125,7 @@ class RelationshipsExtractor(BaseExtractor):
                 triples.append(
                     (
                         id_,
-                        namespace.created_time,
+                        self.namespace.created_time,
                         Literal(datetime.fromtimestamp(relationship.created_time / 1000, timezone.utc)),
                     )
                 )
@@ -131,7 +134,7 @@ class RelationshipsExtractor(BaseExtractor):
                 triples.append(
                     (
                         id_,
-                        namespace.last_updated_time,
+                        self.namespace.last_updated_time,
                         Literal(datetime.fromtimestamp(relationship.last_updated_time / 1000, timezone.utc)),
                     )
                 )
@@ -140,7 +143,7 @@ class RelationshipsExtractor(BaseExtractor):
                 triples.append(
                     (
                         id_,
-                        namespace.confidence,
+                        self.namespace.confidence,
                         Literal(relationship.confidence),
                     )
                 )
@@ -149,11 +152,23 @@ class RelationshipsExtractor(BaseExtractor):
                 for label in relationship.labels:
                     # external_id can create ill-formed URIs, so we create websafe URIs
                     # since labels do not have internal ids, we use the external_id as the id
-                    triples.append((id_, namespace.label, namespace[f"Label_{quote(label.dump()['externalId'])}"]))
+                    triples.append(
+                        (
+                            id_,
+                            self.namespace.label,
+                            self.namespace[f"Label_{quote(label.dump()['externalId'])}"],
+                        )
+                    )
 
             # Create connection
             if relationship.data_set_id:
-                triples.append((id_, namespace.dataset, namespace[f"Dataset_{relationship.data_set_id}"]))
+                triples.append(
+                    (
+                        id_,
+                        self.namespace.dataset,
+                        self.namespace[f"Dataset_{relationship.data_set_id}"],
+                    )
+                )
 
             return triples
         return []

cognite/neat/graph/extractors/_classic_cdf/_sequences.py

@@ -1,3 +1,4 @@
+import json
 from collections.abc import Iterable
 from datetime import datetime, timezone
 from pathlib import Path
@@ -20,15 +21,19 @@ class SequencesExtractor(BaseExtractor):
     Args:
         sequence (Iterable[Sequence]): An iterable of sequences.
         namespace (Namespace, optional): The namespace to use. Defaults to DEFAULT_NAMESPACE.
+        unpack_metadata (bool, optional): Whether to unpack metadata. Defaults to False, which yields the metadata as
+            a JSON string.
     """
 
     def __init__(
         self,
         sequence: Iterable[Sequence],
         namespace: Namespace | None = None,
+        unpack_metadata: bool = False,
     ):
         self.namespace = namespace or DEFAULT_NAMESPACE
         self.sequence = sequence
+        self.unpack_metadata = unpack_metadata
 
     @classmethod
     def from_dataset(
@@ -36,50 +41,71 @@ class SequencesExtractor(BaseExtractor):
         client: CogniteClient,
         data_set_external_id: str,
         namespace: Namespace | None = None,
+        unpack_metadata: bool = False,
     ):
-        return cls(cast(Iterable[Sequence], client.sequences(data_set_external_ids=data_set_external_id)), namespace)
+        return cls(
+            cast(
+                Iterable[Sequence],
+                client.sequences(data_set_external_ids=data_set_external_id),
+            ),
+            namespace,
+            unpack_metadata,
+        )
 
     @classmethod
-    def from_file(cls, file_path: str, namespace: Namespace | None = None):
-        return cls(SequenceList.load(Path(file_path).read_text()), namespace)
+    def from_file(
+        cls,
+        file_path: str,
+        namespace: Namespace | None = None,
+        unpack_metadata: bool = False,
+    ):
+        return cls(SequenceList.load(Path(file_path).read_text()), namespace, unpack_metadata)
 
     def extract(self) -> Iterable[Triple]:
         """Extract sequences as triples."""
         for sequence in self.sequence:
-            yield from self._sequence2triples(sequence, self.namespace)
+            yield from self._sequence2triples(sequence)
 
-    @classmethod
-    def _sequence2triples(cls, sequence: Sequence, namespace: Namespace) -> list[Triple]:
-        id_ = namespace[f"Sequence_{sequence.id}"]
+    def _sequence2triples(self, sequence: Sequence) -> list[Triple]:
+        id_ = self.namespace[f"Sequence_{sequence.id}"]
 
         # Set rdf type
-        triples: list[Triple] = [(id_, RDF.type, namespace.Sequence)]
+        triples: list[Triple] = [(id_, RDF.type, self.namespace.Sequence)]
 
         # Create attributes
 
         if sequence.external_id:
-            triples.append((id_, namespace.external_id, Literal(sequence.external_id)))
+            triples.append((id_, self.namespace.external_id, Literal(sequence.external_id)))
 
         if sequence.name:
-            triples.append((id_, namespace.name, Literal(sequence.name)))
+            triples.append((id_, self.namespace.name, Literal(sequence.name)))
 
         if sequence.metadata:
-            for key, value in sequence.metadata.items():
-                if value:
-                    type_aware_value = string_to_ideal_type(value)
-                    try:
-                        triples.append((id_, namespace[key], URIRef(str(AnyHttpUrl(type_aware_value)))))  # type: ignore
-                    except ValidationError:
-                        triples.append((id_, namespace[key], Literal(type_aware_value)))
+            if self.unpack_metadata:
+                for key, value in sequence.metadata.items():
+                    if value:
+                        type_aware_value = string_to_ideal_type(value)
+                        try:
+                            triples.append((id_, self.namespace[key], URIRef(str(AnyHttpUrl(type_aware_value)))))  # type: ignore
+                        except ValidationError:
+                            triples.append((id_, self.namespace[key], Literal(type_aware_value)))
+            else:
+                triples.append(
+                    (
+                        id_,
+                        self.namespace.metadata,
+                        Literal(json.dumps(sequence.metadata)),
+                    )
+                )
 
         if sequence.description:
-            triples.append((id_, namespace.description, Literal(sequence.description)))
+            triples.append((id_, self.namespace.description, Literal(sequence.description)))
 
         if sequence.created_time:
             triples.append(
                 (
                     id_,
-                    namespace.created_time,
+                    self.namespace.created_time,
                     Literal(datetime.fromtimestamp(sequence.created_time / 1000, timezone.utc)),
                 )
             )
@@ -88,15 +114,27 @@ class SequencesExtractor(BaseExtractor):
             triples.append(
                 (
                     id_,
-                    namespace.last_updated_time,
+                    self.namespace.last_updated_time,
                     Literal(datetime.fromtimestamp(sequence.last_updated_time / 1000, timezone.utc)),
                 )
             )
 
         if sequence.data_set_id:
-            triples.append((id_, namespace.data_set_id, namespace[f"Dataset_{sequence.data_set_id}"]))
+            triples.append(
+                (
+                    id_,
+                    self.namespace.data_set_id,
+                    self.namespace[f"Dataset_{sequence.data_set_id}"],
+                )
+            )
 
         if sequence.asset_id:
-            triples.append((id_, namespace.asset, namespace[f"Asset_{sequence.asset_id}"]))
+            triples.append(
+                (
+                    id_,
+                    self.namespace.asset,
+                    self.namespace[f"Asset_{sequence.asset_id}"],
+                )
+            )
 
         return triples

cognite/neat/graph/extractors/_classic_cdf/_timeseries.py

@@ -1,3 +1,4 @@
+import json
 from collections.abc import Iterable
 from datetime import datetime, timezone
 from pathlib import Path
@@ -20,15 +21,19 @@ class TimeSeriesExtractor(BaseExtractor):
     Args:
         timeseries (Iterable[TimeSeries]): An iterable of timeseries.
         namespace (Namespace, optional): The namespace to use. Defaults to DEFAULT_NAMESPACE.
+        unpack_metadata (bool, optional): Whether to unpack metadata. Defaults to False, which yields the metadata as
+            a JSON string.
     """
 
     def __init__(
         self,
         timeseries: Iterable[TimeSeries],
         namespace: Namespace | None = None,
+        unpack_metadata: bool = False,
     ):
         self.namespace = namespace or DEFAULT_NAMESPACE
         self.timeseries = timeseries
+        self.unpack_metadata = unpack_metadata
 
     @classmethod
     def from_dataset(
@@ -36,65 +41,84 @@ class TimeSeriesExtractor(BaseExtractor):
         client: CogniteClient,
         data_set_external_id: str,
         namespace: Namespace | None = None,
+        unpack_metadata: bool = False,
     ):
         return cls(
-            cast(Iterable[TimeSeries], client.time_series(data_set_external_ids=data_set_external_id)), namespace
+            cast(
+                Iterable[TimeSeries],
+                client.time_series(data_set_external_ids=data_set_external_id),
+            ),
+            namespace,
+            unpack_metadata,
         )
 
     @classmethod
-    def from_file(cls, file_path: str, namespace: Namespace | None = None):
-        return cls(TimeSeriesList.load(Path(file_path).read_text()), namespace)
+    def from_file(
+        cls,
+        file_path: str,
+        namespace: Namespace | None = None,
+        unpack_metadata: bool = False,
+    ):
+        return cls(TimeSeriesList.load(Path(file_path).read_text()), namespace, unpack_metadata)
 
     def extract(self) -> Iterable[Triple]:
         """Extract timeseries as triples."""
         for timeseries in self.timeseries:
-            yield from self._timeseries2triples(timeseries, self.namespace)
+            yield from self._timeseries2triples(timeseries)
 
-    @classmethod
-    def _timeseries2triples(cls, timeseries: TimeSeries, namespace: Namespace) -> list[Triple]:
-        id_ = namespace[f"TimeSeries_{timeseries.id}"]
+    def _timeseries2triples(self, timeseries: TimeSeries) -> list[Triple]:
+        id_ = self.namespace[f"TimeSeries_{timeseries.id}"]
 
         # Set rdf type
-        triples: list[Triple] = [(id_, RDF.type, namespace.TimeSeries)]
+        triples: list[Triple] = [(id_, RDF.type, self.namespace.TimeSeries)]
 
         # Create attributes
 
         if timeseries.external_id:
-            triples.append((id_, namespace.external_id, Literal(timeseries.external_id)))
+            triples.append((id_, self.namespace.external_id, Literal(timeseries.external_id)))
 
         if timeseries.name:
-            triples.append((id_, namespace.name, Literal(timeseries.name)))
+            triples.append((id_, self.namespace.name, Literal(timeseries.name)))
 
         if timeseries.is_string:
-            triples.append((id_, namespace.is_string, Literal(timeseries.is_string)))
+            triples.append((id_, self.namespace.is_string, Literal(timeseries.is_string)))
 
         if timeseries.metadata:
-            for key, value in timeseries.metadata.items():
-                if value:
-                    type_aware_value = string_to_ideal_type(value)
-                    try:
-                        triples.append((id_, namespace[key], URIRef(str(AnyHttpUrl(type_aware_value)))))  # type: ignore
-                    except ValidationError:
-                        triples.append((id_, namespace[key], Literal(type_aware_value)))
+            if self.unpack_metadata:
+                for key, value in timeseries.metadata.items():
+                    if value:
+                        type_aware_value = string_to_ideal_type(value)
+                        try:
+                            triples.append((id_, self.namespace[key], URIRef(str(AnyHttpUrl(type_aware_value)))))  # type: ignore
+                        except ValidationError:
+                            triples.append((id_, self.namespace[key], Literal(type_aware_value)))
+            else:
+                triples.append(
+                    (
+                        id_,
+                        self.namespace.metadata,
+                        Literal(json.dumps(timeseries.metadata)),
+                    )
+                )
 
         if timeseries.unit:
-            triples.append((id_, namespace.unit, Literal(timeseries.unit)))
+            triples.append((id_, self.namespace.unit, Literal(timeseries.unit)))
 
-        if namespace.is_step:
-            triples.append((id_, namespace.is_step, Literal(timeseries.is_step)))
+        if self.namespace.is_step:
+            triples.append((id_, self.namespace.is_step, Literal(timeseries.is_step)))
 
         if timeseries.description:
-            triples.append((id_, namespace.description, Literal(timeseries.description)))
+            triples.append((id_, self.namespace.description, Literal(timeseries.description)))
 
         if timeseries.security_categories:
             for category in timeseries.security_categories:
-                triples.append((id_, namespace.security_categories, Literal(category)))
+                triples.append((id_, self.namespace.security_categories, Literal(category)))
 
         if timeseries.created_time:
             triples.append(
                 (
                     id_,
-                    namespace.created_time,
+                    self.namespace.created_time,
                     Literal(datetime.fromtimestamp(timeseries.created_time / 1000, timezone.utc)),
                 )
             )
@@ -103,26 +127,50 @@ class TimeSeriesExtractor(BaseExtractor):
             triples.append(
                 (
                     id_,
-                    namespace.last_updated_time,
+                    self.namespace.last_updated_time,
                     Literal(datetime.fromtimestamp(timeseries.last_updated_time / 1000, timezone.utc)),
                 )
             )
 
         if timeseries.legacy_name:
-            triples.append((id_, namespace.legacy_name, Literal(timeseries.legacy_name)))
+            triples.append((id_, self.namespace.legacy_name, Literal(timeseries.legacy_name)))
 
         # Create connections
         if timeseries.unit_external_id:
             # try to create connection to QUDT unit catalog
             try:
-                triples.append((id_, namespace.unit_external_id, URIRef(str(AnyHttpUrl(timeseries.unit_external_id)))))
+                triples.append(
+                    (
+                        id_,
+                        self.namespace.unit_external_id,
+                        URIRef(str(AnyHttpUrl(timeseries.unit_external_id))),
+                    )
+                )
             except ValidationError:
-                triples.append((id_, namespace.unit_external_id, Literal(timeseries.unit_external_id)))
+                triples.append(
+                    (
+                        id_,
+                        self.namespace.unit_external_id,
+                        Literal(timeseries.unit_external_id),
+                    )
+                )
 
         if timeseries.data_set_id:
-            triples.append((id_, namespace.dataset, namespace[f"Dataset_{timeseries.data_set_id}"]))
+            triples.append(
+                (
+                    id_,
+                    self.namespace.dataset,
+                    self.namespace[f"Dataset_{timeseries.data_set_id}"],
+                )
+            )
 
         if timeseries.asset_id:
-            triples.append((id_, namespace.asset, namespace[f"Asset_{timeseries.asset_id}"]))
+            triples.append(
+                (
+                    id_,
+                    self.namespace.asset,
+                    self.namespace[f"Asset_{timeseries.asset_id}"],
+                )
+            )
 
         return triples

cognite/neat/rules/importers/_inference2rules.py

@@ -36,28 +36,36 @@ class InferenceImporter(BaseImporter):
     """Infers rules from a triple store.
 
     Rules inference through analysis of knowledge graph provided in various formats.
-    Use the factory methods to create an triples store from sources such as
+    Use the factory methods to create a triple store from sources such as
     RDF files, JSON files, YAML files, XML files, or directly from a graph store.
 
     Args:
         issue_list: Issue list to store issues
         graph: Knowledge graph
         max_number_of_instance: Maximum number of instances to be used in inference
+        prefix: Prefix to be used for the inferred model
     """
 
-    def __init__(self, issue_list: IssueList, graph: Graph, max_number_of_instance: int = -1):
+    def __init__(
+        self, issue_list: IssueList, graph: Graph, max_number_of_instance: int = -1, prefix: str = "inferred"
+    ) -> None:
         self.issue_list = issue_list
         self.graph = graph
         self.max_number_of_instance = max_number_of_instance
+        self.prefix = prefix
 
     @classmethod
-    def from_graph_store(cls, store: NeatGraphStore, max_number_of_instance: int = -1):
+    def from_graph_store(
+        cls, store: NeatGraphStore, max_number_of_instance: int = -1, prefix: str = "inferred"
+    ) -> "InferenceImporter":
         issue_list = IssueList(title="Inferred from graph store")
 
-        return cls(issue_list, store.graph, max_number_of_instance=max_number_of_instance)
+        return cls(issue_list, store.graph, max_number_of_instance=max_number_of_instance, prefix=prefix)
 
     @classmethod
-    def from_rdf_file(cls, filepath: Path, max_number_of_instance: int = -1):
+    def from_rdf_file(
+        cls, filepath: Path, max_number_of_instance: int = -1, prefix: str = "inferred"
+    ) -> "InferenceImporter":
         issue_list = IssueList(title=f"'{filepath.name}'")
 
         graph = Graph()
@@ -66,18 +74,24 @@ class InferenceImporter(BaseImporter):
         except Exception:
             issue_list.append(issues.fileread.FileReadError(filepath))
 
-        return cls(issue_list, graph, max_number_of_instance=max_number_of_instance)
+        return cls(issue_list, graph, max_number_of_instance=max_number_of_instance, prefix=prefix)
 
     @classmethod
-    def from_json_file(cls, filepath: Path, max_number_of_instance: int = -1):
+    def from_json_file(
+        cls, filepath: Path, max_number_of_instance: int = -1, prefix: str = "inferred"
+    ) -> "InferenceImporter":
         raise NotImplementedError("JSON file format is not supported yet.")
 
     @classmethod
-    def from_yaml_file(cls, filepath: Path, max_number_of_instance: int = -1):
+    def from_yaml_file(
+        cls, filepath: Path, max_number_of_instance: int = -1, prefix: str = "inferred"
+    ) -> "InferenceImporter":
         raise NotImplementedError("YAML file format is not supported yet.")
 
     @classmethod
-    def from_xml_file(cls, filepath: Path, max_number_of_instance: int = -1):
+    def from_xml_file(
+        cls, filepath: Path, max_number_of_instance: int = -1, prefix: str = "inferred"
+    ) -> "InferenceImporter":
         raise NotImplementedError("JSON file format is not supported yet.")
 
     @overload
@@ -239,8 +253,7 @@ class InferenceImporter(BaseImporter):
         if Namespace(get_namespace(URI)) not in prefixes.values():
             prefixes[f"prefix-{len(prefixes)+1}"] = Namespace(get_namespace(URI))
 
-    @classmethod
-    def _default_metadata(cls):
+    def _default_metadata(self):
         return InformationMetadata(
             name="Inferred Model",
             creator="NEAT",
@@ -248,7 +261,7 @@ class InferenceImporter(BaseImporter):
             created=datetime.now(),
             updated=datetime.now(),
             description="Inferred model from knowledge graph",
-            prefix="inferred",
+            prefix=self.prefix,
             namespace=DEFAULT_NAMESPACE,
         )
 
@@ -262,12 +275,9 @@ class InferenceImporter(BaseImporter):
 
     @classmethod
     def _read_value_type_occurrence_from_comment(cls, value_type: str, comment: str) -> int:
-        return int(
-            cast(
-                re.Match,
-                re.search(
-                    rf"with value type <{value_type}> which occurs <(\d+)> times in the graph",
-                    comment,
-                ),
-            ).group(1)
-        )
+        if result := re.search(
+            rf"with value type <{value_type}> which occurs <(\d+)> times in the graph",
+            comment,
+        ):
+            return int(result.group(1))
+        return 0

{cognite_neat-0.85.7.dist-info → cognite_neat-0.85.8.dist-info}/METADATA

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

{cognite_neat-0.85.7.dist-info → cognite_neat-0.85.8.dist-info}/RECORD

@@ -1,6 +1,6 @@
 cognite/neat/__init__.py,sha256=AiexNcHdAHFbrrbo9c65gtil1dqx_SGraDH1PSsXjKE,126
 cognite/neat/_shared.py,sha256=RSaHm2eJceTlvb-hMMe4nHgoHdPYDfN3XcxDXo24k3A,1530
-cognite/neat/_version.py,sha256=hVJ3xHshW3ChykiL5r0Maacil2KmJncrUYZGRzPoqic,23
+cognite/neat/_version.py,sha256=XNxvWbbG3Du3rtKNhMT-MnhnUVoPrUHeH989x6qqhYo,23
 cognite/neat/app/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/app/api/asgi/metrics.py,sha256=nxFy7L5cChTI0a-zkCiJ59Aq8yLuIJp5c9Dg0wRXtV0,152
 cognite/neat/app/api/configuration.py,sha256=2U5M6M252swvQPQyooA1EBzFUZNtcTmuSaywfJDgckM,4232
@@ -57,13 +57,13 @@ cognite/neat/graph/exceptions.py,sha256=R6pyOH774n9w2x_X_nrUr8OMAdjJMf_XPIqAvxIQ
 cognite/neat/graph/extractors/__init__.py,sha256=nXcNp6i3-1HteIkr8Ujxk4b09W5jk27Q3eWuwjcnGnM,1647
 cognite/neat/graph/extractors/_base.py,sha256=8IWygpkQTwo0UOmbbwWVI7540_klTVdUVX2JjVPFRIs,498
 cognite/neat/graph/extractors/_classic_cdf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cognite/neat/graph/extractors/_classic_cdf/_assets.py,sha256=xrinx9SF9WMrrbbsYr2eSi7ZGOmlia3ltPq573fAoVg,4809
-cognite/neat/graph/extractors/_classic_cdf/_events.py,sha256=SGZWKCxppECIQkwQs5M2e_SoF-eGilCW2KiyXk2PmzM,4230
-cognite/neat/graph/extractors/_classic_cdf/_files.py,sha256=o35K0_ouq7hjR_lAVRjWbuRsuAzlS78S_97am5TFU5A,5129
-cognite/neat/graph/extractors/_classic_cdf/_labels.py,sha256=4JxQHPDciMjbk7F6GxMa-HfhOgAv8LT3VO3mRfEgQ0E,2832
-cognite/neat/graph/extractors/_classic_cdf/_relationships.py,sha256=jgIN__nztlhLwoIJw59s2-Blc9gxIm7YDha5qEoXBSg,5654
-cognite/neat/graph/extractors/_classic_cdf/_sequences.py,sha256=5FuhwpgDiGG51C0bQacQ4LD6KkutUaU1cX2NSy_krhU,3652
-cognite/neat/graph/extractors/_classic_cdf/_timeseries.py,sha256=Ui7WRAvot3KJFwpzqmEYvRs3cN0qh93ocJjYaNLfH30,4811
+cognite/neat/graph/extractors/_classic_cdf/_assets.py,sha256=ZLLiHlN0RB4Drx0b0uBLLiV8gowlMleamRBSKUrCgyI,7854
+cognite/neat/graph/extractors/_classic_cdf/_events.py,sha256=UiysU7AGlWMQuEMObaJN1JvMNWWtXmjBzFsk3SLg8V4,5112
+cognite/neat/graph/extractors/_classic_cdf/_files.py,sha256=TPjDF6VfRImhrJlfFNne3Plm6NmrGwtaGKqP_vZ8s6Y,6289
+cognite/neat/graph/extractors/_classic_cdf/_labels.py,sha256=9DQ1hblU3gbLTbWuthKLWkSL_eNH69izitzMSQ1FdD8,3011
+cognite/neat/graph/extractors/_classic_cdf/_relationships.py,sha256=GzxnvIflmHVnWdlNFoLrnxJjM8c2YuMzzMC7IL7Q4cg,6040
+cognite/neat/graph/extractors/_classic_cdf/_sequences.py,sha256=3L2c7z1I4LQZYgA8CScsOGfvamIdCc19I5ZIzPVVgsM,4680
+cognite/neat/graph/extractors/_classic_cdf/_timeseries.py,sha256=HCUjTTLqj9rTxb7xemyxNXYRqsKVUzRAXi0BLyo2Ctc,6125
 cognite/neat/graph/extractors/_dexpi.py,sha256=xIw3kSaQ17k_bAuecvrVRic70PUhFHtcyy-ReLt36Q4,9385
 cognite/neat/graph/extractors/_mock_graph_generator.py,sha256=w6lIgwvVwkvK725S9MLFZU8lLxjxXt_621_nChupAkQ,14791
 cognite/neat/graph/extractors/_rdf_file.py,sha256=ialMCLv9WH5k6v1YMfozfcmAYhz8OVo9jVhsKMyQkDA,763
@@ -203,7 +203,7 @@ cognite/neat/rules/importers/_dtdl2rules/_unit_lookup.py,sha256=wW4saKva61Q_i17g
 cognite/neat/rules/importers/_dtdl2rules/dtdl_converter.py,sha256=ysmWUxZ0npwrTB0uiH5jA0v37sfCwowGaYk17IyxPUU,12663
 cognite/neat/rules/importers/_dtdl2rules/dtdl_importer.py,sha256=Psj3C2jembY_Wu7WWJIFIwrMawvjISjeqfBnoRy_csw,6740
 cognite/neat/rules/importers/_dtdl2rules/spec.py,sha256=tim_MfN1J0F3Oeqk3BMgIA82d_MZvhRuRMsLK3B4PYc,11897
-cognite/neat/rules/importers/_inference2rules.py,sha256=TlzTpO1IUyeUjODuDLqnlC-LeLhT-S6V6OpL-5YSQRo,11801
+cognite/neat/rules/importers/_inference2rules.py,sha256=S_U2M8z5oZaFD3yPDSG__xUJSCmFkQyrKleHixrzYlU,12204
 cognite/neat/rules/importers/_owl2rules/__init__.py,sha256=tdGcrgtozdQyST-pTlxIa4cLBNTLvtk1nNYR4vOdFSw,63
 cognite/neat/rules/importers/_owl2rules/_owl2classes.py,sha256=dACjYeCa_OhpQgqccI4w478dEINbISUMzpVkCOoRRL8,7384
 cognite/neat/rules/importers/_owl2rules/_owl2metadata.py,sha256=nwnUaBNAAYMoBre2UmsnkJXUuaqGEpR3U3txDrH2w6g,7527
@@ -310,8 +310,8 @@ cognite/neat/workflows/steps_registry.py,sha256=fkTX14ZA7_gkUYfWIlx7A1XbCidvqR23
 cognite/neat/workflows/tasks.py,sha256=dqlJwKAb0jlkl7abbY8RRz3m7MT4SK8-7cntMWkOYjw,788
 cognite/neat/workflows/triggers.py,sha256=_BLNplzoz0iic367u1mhHMHiUrCwP-SLK6_CZzfODX0,7071
 cognite/neat/workflows/utils.py,sha256=gKdy3RLG7ctRhbCRwaDIWpL9Mi98zm56-d4jfHDqP1E,453
-cognite_neat-0.85.7.dist-info/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
-cognite_neat-0.85.7.dist-info/METADATA,sha256=FOumx12OP-CCVVbdM2preeoHr-pPzrxnLKzYbaGsETU,9493
-cognite_neat-0.85.7.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-cognite_neat-0.85.7.dist-info/entry_points.txt,sha256=61FPqiWb25vbqB0KI7znG8nsg_ibLHBvTjYnkPvNFso,50
-cognite_neat-0.85.7.dist-info/RECORD,,
+cognite_neat-0.85.8.dist-info/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
+cognite_neat-0.85.8.dist-info/METADATA,sha256=LMGF9Z866Ni01TGc12LHk09EjNbbSxjiZS-gzMtvGsY,9493
+cognite_neat-0.85.8.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+cognite_neat-0.85.8.dist-info/entry_points.txt,sha256=61FPqiWb25vbqB0KI7znG8nsg_ibLHBvTjYnkPvNFso,50
+cognite_neat-0.85.8.dist-info/RECORD,,