cognite-neat 0.98.0__py3-none-any.whl → 0.99.1__py3-none-any.whl

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

@@ -1,177 +1,37 @@
-from collections.abc import Callable, Iterable, Set
-from datetime import datetime, timezone
+from collections.abc import Iterable
 from pathlib import Path
 from typing import cast
 
 from cognite.client import CogniteClient
 from cognite.client.data_classes import Asset, AssetFilter, AssetList
-from rdflib import RDF, Literal, Namespace
 
-from cognite.neat._shared import Triple
-
-from ._base import DEFAULT_SKIP_METADATA_VALUES, ClassicCDFBaseExtractor, InstanceIdPrefix
-from ._labels import LabelsExtractor
+from ._base import ClassicCDFBaseExtractor, InstanceIdPrefix
 
 
 class AssetsExtractor(ClassicCDFBaseExtractor[Asset]):
-    """Extract data from Cognite Data Fusions Assets into Neat.
-
-    Args:
-        items (Iterable[Asset]): An iterable of assets.
-        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.
-        skip_metadata_values (set[str] | frozenset[str] | None, optional): A set of values to skip when unpacking
-            metadata. Defaults to frozenset({"nan", "null", "none", ""}).
-    """
+    """Extract data from Cognite Data Fusions Assets into Neat."""
 
     _default_rdf_type = "Asset"
+    _instance_id_prefix = InstanceIdPrefix.asset
 
     @classmethod
-    def from_dataset(
-        cls,
-        client: CogniteClient,
-        data_set_external_id: str,
-        namespace: Namespace | None = None,
-        to_type: Callable[[Asset], str | None] | None = None,
-        limit: int | None = None,
-        unpack_metadata: bool = True,
-        skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
-    ):
+    def _from_dataset(cls, client: CogniteClient, data_set_external_id: str) -> tuple[int | None, Iterable[Asset]]:
         total = client.assets.aggregate_count(filter=AssetFilter(data_set_ids=[{"externalId": data_set_external_id}]))
-
-        return cls(
-            client.assets(data_set_external_ids=data_set_external_id),
-            namespace,
-            to_type,
-            total,
-            limit,
-            unpack_metadata=unpack_metadata,
-            skip_metadata_values=skip_metadata_values,
-        )
+        items = client.assets(data_set_external_ids=data_set_external_id)
+        return total, items
 
     @classmethod
-    def from_hierarchy(
-        cls,
-        client: CogniteClient,
-        root_asset_external_id: str,
-        namespace: Namespace | None = None,
-        to_type: Callable[[Asset], str | None] | None = None,
-        limit: int | None = None,
-        unpack_metadata: bool = True,
-        skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
-    ):
+    def _from_hierarchy(cls, client: CogniteClient, root_asset_external_id: str) -> tuple[int | None, Iterable[Asset]]:
         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,
-            total,
-            limit,
-            unpack_metadata=unpack_metadata,
-            skip_metadata_values=skip_metadata_values,
+        items = cast(
+            Iterable[Asset],
+            client.assets(asset_subtree_external_ids=root_asset_external_id),
         )
+        return total, items
 
     @classmethod
-    def from_file(
-        cls,
-        file_path: str,
-        namespace: Namespace | None = None,
-        to_type: Callable[[Asset], str] | None = None,
-        limit: int | None = None,
-        unpack_metadata: bool = True,
-        skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
-    ):
+    def _from_file(cls, file_path: str | Path) -> tuple[int | None, Iterable[Asset]]:
         assets = AssetList.load(Path(file_path).read_text())
-        return cls(
-            assets,
-            namespace,
-            to_type,
-            total=len(assets),
-            limit=limit,
-            unpack_metadata=unpack_metadata,
-            skip_metadata_values=skip_metadata_values,
-        )
-
-    def _item2triples(self, asset: Asset) -> list[Triple]:
-        """Converts an asset to triples."""
-        id_ = self.namespace[f"{InstanceIdPrefix.asset}{asset.id}"]
-
-        type_ = self._get_rdf_type(asset)
-
-        triples: list[Triple] = [(id_, RDF.type, self.namespace[type_])]
-
-        # Create attributes
-        if asset.name:
-            triples.append((id_, self.namespace.name, Literal(asset.name)))
-
-        if asset.description:
-            triples.append((id_, self.namespace.description, Literal(asset.description)))
-
-        if asset.external_id:
-            triples.append((id_, self.namespace.external_id, Literal(asset.external_id)))
-
-        if asset.source:
-            triples.append((id_, self.namespace.source, Literal(asset.source)))
-
-        # properties' ref creation and update
-        triples.append(
-            (
-                id_,
-                self.namespace.created_time,
-                Literal(datetime.fromtimestamp(asset.created_time / 1000, timezone.utc)),
-            )
-        )
-        triples.append(
-            (
-                id_,
-                self.namespace.last_updated_time,
-                Literal(datetime.fromtimestamp(asset.last_updated_time / 1000, timezone.utc)),
-            )
-        )
-
-        if asset.labels:
-            for label in asset.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_,
-                        self.namespace.label,
-                        self.namespace[f"{InstanceIdPrefix.label}{LabelsExtractor._label_id(label)}"],
-                    )
-                )
-
-        if asset.metadata:
-            triples.extend(self._metadata_to_triples(id_, asset.metadata))
-
-        # Create connections:
-        if asset.parent_id:
-            triples.append((id_, self.namespace.parent, self.namespace[f"{InstanceIdPrefix.asset}{asset.parent_id}"]))
-
-        if asset.root_id:
-            triples.append((id_, self.namespace.root, self.namespace[f"{InstanceIdPrefix.asset}{asset.root_id}"]))
-
-        if asset.data_set_id:
-            triples.append(
-                (
-                    id_,
-                    self.namespace.dataset,
-                    self.namespace[f"{InstanceIdPrefix.data_set}{asset.data_set_id}"],
-                )
-            )
-
-        return triples
+        return len(assets), assets

cognite/neat/_graph/extractors/_classic_cdf/_base.py

@@ -2,18 +2,22 @@ import json
 import re
 import sys
 from abc import ABC, abstractmethod
-from collections.abc import Callable, Iterable, Set
-from typing import Generic, TypeVar
+from collections.abc import Callable, Iterable, Sequence, Set
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Generic, TypeVar
 
-from cognite.client.data_classes._base import CogniteResource
-from rdflib import XSD, Literal, Namespace, URIRef
+from cognite.client import CogniteClient
+from cognite.client.data_classes._base import WriteableCogniteResource
+from pydantic import AnyHttpUrl, ValidationError
+from rdflib import RDF, XSD, Literal, Namespace, URIRef
 
 from cognite.neat._constants import DEFAULT_NAMESPACE
 from cognite.neat._graph.extractors._base import BaseExtractor
 from cognite.neat._shared import Triple
 from cognite.neat._utils.auxiliary import string_to_ideal_type
 
-T_CogniteResource = TypeVar("T_CogniteResource", bound=CogniteResource)
+T_CogniteResource = TypeVar("T_CogniteResource", bound=WriteableCogniteResource)
 
 DEFAULT_SKIP_METADATA_VALUES = frozenset({"nan", "null", "none", ""})
 
@@ -61,9 +65,13 @@ class ClassicCDFBaseExtractor(BaseExtractor, ABC, Generic[T_CogniteResource]):
             a JSON string.
         skip_metadata_values (set[str] | frozenset[str] | None, optional): If you are unpacking metadata, then
            values in this set will be skipped.
+        camel_case (bool, optional): Whether to use camelCase instead of snake_case for property names.
+            Defaults to True.
+        as_write (bool, optional): Whether to use the write/request format of the items. Defaults to False.
     """
 
     _default_rdf_type: str
+    _instance_id_prefix: str
     _SPACE_PATTERN = re.compile(r"\s+")
 
     def __init__(
@@ -75,6 +83,8 @@ class ClassicCDFBaseExtractor(BaseExtractor, ABC, Generic[T_CogniteResource]):
         limit: int | None = None,
         unpack_metadata: bool = True,
         skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
+        camel_case: bool = True,
+        as_write: bool = False,
     ):
         self.namespace = namespace or DEFAULT_NAMESPACE
         self.items = items
@@ -83,6 +93,8 @@ class ClassicCDFBaseExtractor(BaseExtractor, ABC, Generic[T_CogniteResource]):
         self.limit = min(limit, total) if limit and total else limit
         self.unpack_metadata = unpack_metadata
         self.skip_metadata_values = skip_metadata_values
+        self.camel_case = camel_case
+        self.as_write = as_write
 
     def extract(self) -> Iterable[Triple]:
         """Extracts an asset with the given asset_id."""
@@ -104,9 +116,48 @@ class ClassicCDFBaseExtractor(BaseExtractor, ABC, Generic[T_CogniteResource]):
             if self.limit and no >= self.limit:
                 break
 
-    @abstractmethod
     def _item2triples(self, item: T_CogniteResource) -> list[Triple]:
-        raise NotImplementedError()
+        id_value: str | None
+        if hasattr(item, "id"):
+            id_value = str(item.id)
+        else:
+            id_value = self._fallback_id(item)
+        if id_value is None:
+            return []
+
+        id_ = self.namespace[f"{self._instance_id_prefix}{id_value}"]
+
+        type_ = self._get_rdf_type(item)
+
+        # Set rdf type
+        triples: list[Triple] = [(id_, RDF.type, self.namespace[type_])]
+        if self.as_write:
+            item = item.as_write()
+        dumped = item.dump(self.camel_case)
+        dumped.pop("id", None)
+        # We have parentId so we don't need parentExternalId
+        dumped.pop("parentExternalId", None)
+        if "metadata" in dumped:
+            triples.extend(self._metadata_to_triples(id_, dumped.pop("metadata")))
+        if "columns" in dumped:
+            columns = dumped.pop("columns")
+            triples.append(
+                (id_, self.namespace.columns, Literal(json.dumps({"columns": columns}), datatype=XSD._NS["json"]))
+            )
+
+        for key, value in dumped.items():
+            if value is None or value == []:
+                continue
+            values = value if isinstance(value, Sequence) and not isinstance(value, str) else [value]
+            for raw in values:
+                triples.append((id_, self.namespace[key], self._as_object(raw, key)))
+        return triples
+
+    def _fallback_id(self, item: T_CogniteResource) -> str | None:
+        raise AttributeError(
+            f"Item of type {type(item)} does not have an id attribute. "
+            f"Please implement the _fallback_id method in the extractor."
+        )
 
     def _metadata_to_triples(self, id_: URIRef, metadata: dict[str, str]) -> Iterable[Triple]:
         if self.unpack_metadata:
@@ -125,3 +176,99 @@ class ClassicCDFBaseExtractor(BaseExtractor, ABC, Generic[T_CogniteResource]):
         if self.to_type:
             type_ = self.to_type(item) or type_
         return self._SPACE_PATTERN.sub("_", type_)
+
+    def _as_object(self, raw: Any, key: str) -> Literal | URIRef:
+        if key in {"data_set_id", "dataSetId"}:
+            return self.namespace[f"{InstanceIdPrefix.data_set}{raw}"]
+        elif key in {"assetId", "asset_id", "assetIds", "asset_ids", "parentId", "rootId", "parent_id", "root_id"}:
+            return self.namespace[f"{InstanceIdPrefix.asset}{raw}"]
+        elif key in {
+            "startTime",
+            "endTime",
+            "createdTime",
+            "lastUpdatedTime",
+            "start_time",
+            "end_time",
+            "created_time",
+            "last_updated_time",
+        } and isinstance(raw, int):
+            return Literal(datetime.fromtimestamp(raw / 1000, timezone.utc), datatype=XSD.dateTime)
+        elif key == "labels":
+            from ._labels import LabelsExtractor
+
+            return self.namespace[f"{InstanceIdPrefix.label}{LabelsExtractor._label_id(raw)}"]
+        elif key in {"sourceType", "targetType", "source_type", "target_type"} and isinstance(raw, str):
+            # Relationship types. Titled so they can be looked up.
+            return self.namespace[raw.title()]
+        elif key in {"unit_external_id", "unitExternalId"}:
+            try:
+                return URIRef(str(AnyHttpUrl(raw)))
+            except ValidationError:
+                ...
+        return Literal(raw)
+
+    @classmethod
+    def from_dataset(
+        cls,
+        client: CogniteClient,
+        data_set_external_id: str,
+        namespace: Namespace | None = None,
+        to_type: Callable[[T_CogniteResource], str | None] | None = None,
+        limit: int | None = None,
+        unpack_metadata: bool = True,
+        skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
+        camel_case: bool = True,
+        as_write: bool = False,
+    ):
+        total, items = cls._from_dataset(client, data_set_external_id)
+        return cls(items, namespace, to_type, total, limit, unpack_metadata, skip_metadata_values, camel_case, as_write)
+
+    @classmethod
+    @abstractmethod
+    def _from_dataset(
+        cls, client: CogniteClient, data_set_external_id: str
+    ) -> tuple[int | None, Iterable[T_CogniteResource]]:
+        raise NotImplementedError
+
+    @classmethod
+    def from_hierarchy(
+        cls,
+        client: CogniteClient,
+        root_asset_external_id: str,
+        namespace: Namespace | None = None,
+        to_type: Callable[[T_CogniteResource], str | None] | None = None,
+        limit: int | None = None,
+        unpack_metadata: bool = True,
+        skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
+        camel_case: bool = True,
+        as_write: bool = False,
+    ):
+        total, items = cls._from_hierarchy(client, root_asset_external_id)
+        return cls(items, namespace, to_type, total, limit, unpack_metadata, skip_metadata_values, camel_case, as_write)
+
+    @classmethod
+    @abstractmethod
+    def _from_hierarchy(
+        cls, client: CogniteClient, root_asset_external_id: str
+    ) -> tuple[int | None, Iterable[T_CogniteResource]]:
+        raise NotImplementedError
+
+    @classmethod
+    def from_file(
+        cls,
+        file_path: str | Path,
+        namespace: Namespace | None = None,
+        to_type: Callable[[T_CogniteResource], str | None] | None = None,
+        limit: int | None = None,
+        unpack_metadata: bool = True,
+        skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
+        camel_case: bool = True,
+        as_write: bool = False,
+    ):
+        total, items = cls._from_file(file_path)
+        return cls(items, namespace, to_type, total, limit, unpack_metadata, skip_metadata_values, camel_case, as_write)
+
+    @classmethod
+    @abstractmethod
+    def _from_file(cls, file_path: str | Path) -> tuple[int | None, Iterable[T_CogniteResource]]:
+        raise NotImplementedError

cognite/neat/_graph/extractors/_classic_cdf/_classic.py

@@ -1,12 +1,15 @@
+import warnings
 from collections import defaultdict
 from collections.abc import Iterable, Sequence
 from typing import ClassVar, NamedTuple
 
 from cognite.client import CogniteClient
+from cognite.client.exceptions import CogniteAPIError
 from rdflib import Namespace
 
-from cognite.neat._constants import DEFAULT_NAMESPACE
+from cognite.neat._constants import CLASSIC_CDF_NAMESPACE
 from cognite.neat._graph.extractors._base import BaseExtractor
+from cognite.neat._issues.warnings import CDFAuthWarning
 from cognite.neat._shared import Triple
 from cognite.neat._utils.collection_ import chunker
 from cognite.neat._utils.rdf_ import remove_namespace_from_uri
@@ -95,7 +98,8 @@ class ClassicGraphExtractor(BaseExtractor):
             raise ValueError("Exactly one of data_set_external_id or root_asset_external_id must be set.")
         self._root_asset_external_id = root_asset_external_id
         self._data_set_external_id = data_set_external_id
-        self._namespace = namespace or DEFAULT_NAMESPACE
+        self._namespace = namespace or CLASSIC_CDF_NAMESPACE
+        self._extractor_args = dict(namespace=self._namespace, unpack_metadata=False, as_write=True, camel_case=True)
 
         self._source_external_ids_by_type: dict[InstanceIdPrefix, set[str]] = defaultdict(set)
         self._target_external_ids_by_type: dict[InstanceIdPrefix, set[str]] = defaultdict(set)
@@ -110,18 +114,25 @@ class ClassicGraphExtractor(BaseExtractor):
 
         yield from self._extract_core_end_nodes()
 
-        yield from self._extract_labels()
-        yield from self._extract_data_sets()
+        try:
+            yield from self._extract_labels()
+        except CogniteAPIError as e:
+            warnings.warn(CDFAuthWarning("extract labels", str(e)), stacklevel=2)
+
+        try:
+            yield from self._extract_data_sets()
+        except CogniteAPIError as e:
+            warnings.warn(CDFAuthWarning("extract data sets", str(e)), stacklevel=2)
 
     def _extract_core_start_nodes(self):
         for core_node in self._classic_node_types:
             if self._data_set_external_id:
                 extractor = core_node.extractor_cls.from_dataset(
-                    self._client, self._data_set_external_id, self._namespace, unpack_metadata=False
+                    self._client, self._data_set_external_id, **self._extractor_args
                 )
             elif self._root_asset_external_id:
                 extractor = core_node.extractor_cls.from_hierarchy(
-                    self._client, self._root_asset_external_id, self._namespace, unpack_metadata=False
+                    self._client, self._root_asset_external_id, **self._extractor_args
                 )
             else:
                 raise ValueError("Exactly one of data_set_external_id or root_asset_external_id must be set.")
@@ -135,7 +146,7 @@ class ClassicGraphExtractor(BaseExtractor):
                 relationship_iterator = self._client.relationships(
                     source_external_ids=list(chunk), source_types=[start_type]
                 )
-                extractor = RelationshipsExtractor(relationship_iterator, self._namespace, unpack_metadata=False)
+                extractor = RelationshipsExtractor(relationship_iterator, **self._extractor_args)
                 # This is a private attribute, but we need to set it to log the target nodes.
                 extractor._log_target_nodes = True
 
@@ -165,28 +176,28 @@ class ClassicGraphExtractor(BaseExtractor):
                 description=f"Extracting end nodes {core_node.resource_type.removesuffix('_')}",
             ):
                 resource_iterator = api.retrieve_multiple(external_ids=list(chunk), ignore_unknown_ids=True)
-                extractor = core_node.extractor_cls(resource_iterator, self._namespace, unpack_metadata=False)
+                extractor = core_node.extractor_cls(resource_iterator, **self._extractor_args)
                 yield from self._extract_with_logging_label_dataset(extractor)
 
     def _extract_labels(self):
         for chunk in self._chunk(list(self._labels), description="Extracting labels"):
             label_iterator = self._client.labels.retrieve(external_id=list(chunk), ignore_unknown_ids=True)
-            yield from LabelsExtractor(label_iterator, self._namespace).extract()
+            yield from LabelsExtractor(label_iterator, **self._extractor_args).extract()
 
     def _extract_data_sets(self):
         for chunk in self._chunk(list(self._data_set_ids), description="Extracting data sets"):
             data_set_iterator = self._client.data_sets.retrieve_multiple(ids=list(chunk), ignore_unknown_ids=True)
-            yield from DataSetExtractor(data_set_iterator, self._namespace, unpack_metadata=False).extract()
+            yield from DataSetExtractor(data_set_iterator, **self._extractor_args).extract()
 
     def _extract_with_logging_label_dataset(
         self, extractor: ClassicCDFBaseExtractor, resource_type: InstanceIdPrefix | None = None
     ) -> Iterable[Triple]:
         for triple in extractor.extract():
-            if triple[1] == self._namespace.external_id and resource_type is not None:
+            if triple[1] == self._namespace.externalId and resource_type is not None:
                 self._source_external_ids_by_type[resource_type].add(remove_namespace_from_uri(triple[2]))
-            elif triple[1] == self._namespace.label:
+            elif triple[1] == self._namespace.labels:
                 self._labels.add(remove_namespace_from_uri(triple[2]).removeprefix(InstanceIdPrefix.label))
-            elif triple[1] == self._namespace.dataset:
+            elif triple[1] == self._namespace.datasetId:
                 self._data_set_ids.add(
                     int(remove_namespace_from_uri(triple[2]).removeprefix(InstanceIdPrefix.data_set))
                 )
@@ -202,7 +213,7 @@ class ClassicGraphExtractor(BaseExtractor):
         else:
             to_iterate = track(
                 to_iterate,
-                total=(len(items) // 1000) + 1,
+                total=(len(items) // 1_000) + 1,
                 description=description,
             )
         return to_iterate

cognite/neat/_graph/extractors/_classic_cdf/_data_sets.py

@@ -1,110 +1,35 @@
-from collections.abc import Set
-from datetime import datetime, timezone
+from collections.abc import Iterable
 from pathlib import Path
 
 from cognite.client import CogniteClient
 from cognite.client.data_classes import DataSet, DataSetList
 from cognite.client.utils.useful_types import SequenceNotStr
-from rdflib import RDF, Literal, Namespace
 
-from cognite.neat._shared import Triple
-
-from ._base import DEFAULT_SKIP_METADATA_VALUES, ClassicCDFBaseExtractor, InstanceIdPrefix
+from ._base import ClassicCDFBaseExtractor, InstanceIdPrefix, T_CogniteResource
 
 
 class DataSetExtractor(ClassicCDFBaseExtractor[DataSet]):
-    """Extract DataSets from Cognite Data Fusions into Neat.
-
-    Args:
-        items (Iterable[Asset]): An iterable of assets.
-        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.
-        skip_metadata_values (set[str] | frozenset[str] | None, optional): A set of values to skip when unpacking
-            metadata. Defaults to frozenset({"nan", "null", "none", ""}).
-    """
+    """Extract DataSets from Cognite Data Fusions into Neat."""
 
     _default_rdf_type = "DataSet"
+    _instance_id_prefix = InstanceIdPrefix.data_set
 
     @classmethod
-    def from_dataset(
+    def _from_dataset(
         cls,
         client: CogniteClient,
-        data_set_external_id: SequenceNotStr[str],
-        namespace: Namespace | None = None,
-        unpack_metadata: bool = True,
-        skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
-    ):
-        return cls(
-            client.data_sets.retrieve_multiple(external_ids=data_set_external_id),
-            namespace=namespace,
-            total=len(data_set_external_id),
-            unpack_metadata=unpack_metadata,
-            skip_metadata_values=skip_metadata_values,
-        )
+        data_set_external_id: SequenceNotStr[str],  # type: ignore[override]
+    ) -> tuple[int | None, Iterable[DataSet]]:
+        items = client.data_sets.retrieve_multiple(external_ids=data_set_external_id)
+        return len(items), items
 
     @classmethod
-    def from_file(
-        cls,
-        file_path: str,
-        namespace: Namespace | None = None,
-        unpack_metadata: bool = True,
-        skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
-    ):
-        data_sets = DataSetList.load(Path(file_path).read_text())
-        return cls(
-            data_sets,
-            namespace=namespace,
-            total=len(data_sets),
-            unpack_metadata=unpack_metadata,
-            skip_metadata_values=skip_metadata_values,
-        )
-
-    def _item2triples(self, item: DataSet) -> list[Triple]:
-        """Converts an asset to triples."""
-        id_ = self.namespace[f"{InstanceIdPrefix.data_set}{item.id}"]
-
-        type_ = self._get_rdf_type(item)
-
-        triples: list[Triple] = [(id_, RDF.type, self.namespace[type_])]
-
-        # Create attributes
-        if item.name:
-            triples.append((id_, self.namespace.name, Literal(item.name)))
+    def _from_hierarchy(
+        cls, client: CogniteClient, root_asset_external_id: str
+    ) -> tuple[int | None, Iterable[T_CogniteResource]]:
+        raise NotImplementedError("DataSets do not have a hierarchy.")
 
-        if item.description:
-            triples.append((id_, self.namespace.description, Literal(item.description)))
-
-        if item.external_id:
-            triples.append((id_, self.namespace.external_id, Literal(item.external_id)))
-
-        # properties' ref creation and update
-        triples.append(
-            (
-                id_,
-                self.namespace.created_time,
-                Literal(datetime.fromtimestamp(item.created_time / 1000, timezone.utc)),
-            )
-        )
-        triples.append(
-            (
-                id_,
-                self.namespace.last_updated_time,
-                Literal(datetime.fromtimestamp(item.last_updated_time / 1000, timezone.utc)),
-            )
-        )
-
-        if item.write_protected:
-            triples.append((id_, self.namespace.write_protected, Literal(item.write_protected)))
-
-        if item.metadata:
-            triples.extend(self._metadata_to_triples(id_, item.metadata))
-
-        return triples
+    @classmethod
+    def _from_file(cls, file_path: str | Path) -> tuple[int | None, Iterable[DataSet]]:
+        data_sets = DataSetList.load(Path(file_path).read_text())
+        return len(data_sets), data_sets