maite-datasets 0.0.5__py3-none-any.whl → 0.0.6__py3-none-any.whl

maite_datasets/wrappers/_torch.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from typing import Any, Callable, Generic, TypeAlias, TypeVar, cast, overload
+
+import numpy as np
+import torch
+from maite.protocols import DatasetMetadata, DatumMetadata
+from maite.protocols.object_detection import ObjectDetectionTarget as _ObjectDetectionTarget
+from torch import Tensor
+from torchvision.tv_tensors import BoundingBoxes, Image
+
+from maite_datasets._base import BaseDataset, ObjectDetectionTarget
+from maite_datasets.protocols import Array
+
+TArray = TypeVar("TArray", bound=Array)
+TTarget = TypeVar("TTarget")
+
+TorchvisionImageClassificationDatum: TypeAlias = tuple[Image, Tensor, DatumMetadata]
+TorchvisionObjectDetectionDatum: TypeAlias = tuple[Image, ObjectDetectionTarget, DatumMetadata]
+
+
+class TorchvisionWrapper(Generic[TArray, TTarget]):
+    """
+    Lightweight wrapper converting numpy-based datasets to Torchvision tensors.
+
+    Converts images to tv_tensor.Image and targets to the appropriate torchvision format.
+
+    Parameters
+    ----------
+    dataset : Dataset
+        Source dataset with numpy arrays
+    transforms : callable, optional
+        Torchvision v2 transform functions for targets
+    """
+
+    def __init__(
+        self,
+        dataset: BaseDataset[TArray, TTarget],
+        transforms: Callable[[Any], Any] | None = None,
+    ) -> None:
+        self._dataset = dataset
+        self.transforms = transforms
+        self.metadata: DatasetMetadata = {
+            "id": f"TorchvisionWrapper({dataset.metadata['id']})",
+            "index2label": dataset.metadata.get("index2label", {}),
+        }
+
+    def __getattr__(self, name: str) -> Any:
+        """Forward unknown attributes to wrapped dataset."""
+        return getattr(self._dataset, name)
+
+    def __dir__(self) -> list[str]:
+        """Include wrapped dataset attributes in dir() for IDE support."""
+        wrapper_attrs = set(super().__dir__())
+        dataset_attrs = set(dir(self._dataset))
+        return sorted(wrapper_attrs | dataset_attrs)
+
+    def _transform(self, datum: Any) -> Any:
+        return self.transforms(datum) if self.transforms else datum
+
+    @overload
+    def __getitem__(self: TorchvisionWrapper[TArray, TArray], index: int) -> tuple[Image, Tensor, DatumMetadata]: ...
+    @overload
+    def __getitem__(
+        self: TorchvisionWrapper[TArray, TTarget], index: int
+    ) -> tuple[Image, ObjectDetectionTarget, DatumMetadata]: ...
+
+    def __getitem__(self, index: int) -> tuple[Image, Tensor | ObjectDetectionTarget, DatumMetadata]:
+        """Get item with torch tensor conversion."""
+        image, target, metadata = self._dataset[index]
+
+        # Convert image to torch tensor
+        torch_image = torch.from_numpy(image) if isinstance(image, np.ndarray) else torch.as_tensor(image)
+        torch_image = Image(torch_image)
+
+        # Handle different target types
+        if isinstance(target, Array):
+            # Image classification case
+            torch_target = torch.as_tensor(target, dtype=torch.float32)
+            torch_datum = self._transform((torch_image, torch_target, metadata))
+            return cast(TorchvisionImageClassificationDatum, torch_datum)
+
+        if isinstance(target, _ObjectDetectionTarget):
+            # Object detection case
+            torch_boxes = BoundingBoxes(
+                torch.as_tensor(target.boxes), format="XYXY", canvas_size=(torch_image.shape[-2], torch_image.shape[-1])
+            )  # type: ignore
+            torch_labels = torch.as_tensor(target.labels, dtype=torch.int64)
+            torch_scores = torch.as_tensor(target.scores, dtype=torch.float32)
+            torch_target = ObjectDetectionTarget(torch_boxes, torch_labels, torch_scores)
+            torch_datum = self._transform((torch_image, torch_target, metadata))
+            return cast(TorchvisionObjectDetectionDatum, torch_datum)
+
+        raise TypeError(f"Unsupported target type: {type(target)}")
+
+    def __str__(self) -> str:
+        """String representation showing torch version."""
+        nt = "\n    "
+        base_name = f"{self._dataset.__class__.__name__.replace('Dataset', '')} Dataset"
+        title = f"Torchvision Wrapped {base_name}" if not base_name.startswith("Torchvision") else base_name
+        sep = "-" * len(title)
+        attrs = [
+            f"{' '.join(w.capitalize() for w in k.split('_'))}: {v}"
+            for k, v in self.__dict__.items()
+            if not k.startswith("_")
+        ]
+        wrapped = f"{title}\n{sep}{nt}{nt.join(attrs)}"
+        return f"{wrapped}\n\n{self._dataset}"
+
+    def __len__(self) -> int:
+        return self._dataset.__len__()

{maite_datasets-0.0.5.dist-info → maite_datasets-0.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maite-datasets
-Version: 0.0.5
+Version: 0.0.6
 Summary: A collection of Image Classification and Object Detection task datasets conforming to the MAITE protocol.
 Author-email: Andrew Weng <andrew.weng@ariacoustics.com>, Ryan Wood <ryan.wood@ariacoustics.com>, Shaun Jullens <shaun.jullens@ariacoustics.com>
 License-Expression: MIT
@@ -16,6 +16,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.9
 Requires-Dist: defusedxml>=0.7.1
+Requires-Dist: maite<0.9,>=0.7
 Requires-Dist: numpy>=1.24.2
 Requires-Dist: pillow>=10.3.0
 Requires-Dist: requests>=2.32.3
@@ -42,7 +43,7 @@ For status bar indicators when downloading, you can include the extra `tqdm` whe
 pip install maite-datasets[tqdm]
 ```
 
-## Available Datasets
+## Available Downloadable Datasets
 
 | Task           | Dataset          | Description                                                         |
 |----------------|------------------|---------------------------------------------------------------------|
@@ -54,7 +55,7 @@ pip install maite-datasets[tqdm]
 | Detection      | Seadrone         | A UAV dataset focused on open water object detection.               |
 | Detection      | VOCDetection     | [Pascal VOC](http://host.robots.ox.ac.uk/pascal/VOC/) dataset.      |
 
-## Usage
+### Usage
 
 Here is an example of how to import MNIST for usage with your workflow.
 
@@ -76,6 +77,58 @@ MNIST Dataset
 tuple(<class 'numpy.ndarray'>, <class 'numpy.ndarray'>, <class 'dict'>)
 ```
 
+## Dataset Wrappers
+
+Wrappers provide a way to convert datasets to allow usage of tools within specific backend frameworks.
+
+`TorchvisionWrapper` is a convenience class that wraps any of the datasets and provides the capability to apply
+`torchvision` transforms to the dataset.
+
+**NOTE:** `TorchvisionWrapper` requires _torch_ and _torchvision_ to be installed.
+
+```python
+>>> from maite_datasets.object_detection import MILCO
+
+>>> milco = MILCO(root="data", download=True)
+>>> print(milco)
+MILCO Dataset
+-------------
+    Transforms: []
+    Image Set: train
+    Metadata: {'id': 'MILCO_train', 'index2label': {0: 'MILCO', 1: 'NOMBO'}, 'split': 'train'}
+    Path: /home/user/maite-datasets/data/milco
+    Size: 261
+
+>>> print(f"type={milco[0][0].__class__.__name__}, shape={milco[0][0].shape}")
+type=ndarray, shape=(3, 1024, 1024)
+
+>>> print(milco[0][1].boxes[0])
+[ 75. 217. 130. 247.]
+
+>>> from maite_datasets.wrappers import TorchvisionWrapper
+>>> from torchvision.transforms.v2 import Resize
+
+>>> milco_torch = TorchvisionWrapper(milco, transforms=Resize(224))
+>>> print(milco_torch)
+Torchvision Wrapped MILCO Dataset
+---------------------------
+    Transforms: Resize(size=[224], interpolation=InterpolationMode.BILINEAR, antialias=True)
+
+MILCO Dataset
+-------------
+    Transforms: []
+    Image Set: train
+    Metadata: {'id': 'MILCO_train', 'index2label': {0: 'MILCO', 1: 'NOMBO'}, 'split': 'train'}
+    Path: /home/user/maite-datasets/data/milco
+    Size: 261
+
+>>> print(f"type={milco_torch[0][0].__class__.__name__}, shape={milco_torch[0][0].shape}")
+type=Image, shape=torch.Size([3, 224, 224])
+
+>>> print(milco_torch[0][1].boxes[0])
+tensor([16.4062, 47.4688, 28.4375, 54.0312], dtype=torch.float64)
+```
+
 ## Additional Information
 
 For more information on the MAITE protocol, check out their [documentation](https://mit-ll-ai-technology.github.io/maite/).

maite_datasets-0.0.6.dist-info/RECORD

@@ -0,0 +1,26 @@
+maite_datasets/__init__.py,sha256=Z_HyAe08HaHMjzZS2afFumBXYFRFj0ny5ZAIp0hcj4w,569
+maite_datasets/_base.py,sha256=VEd4ipHPAOCbz4Zm8zdI2yQwQ_x9O4Wq01xoZ2QvNYo,12366
+maite_datasets/_builder.py,sha256=MnCh6z5hSINlzBnK_pdbgI5zSg5d1uq4UvXt3cjn9hs,9820
+maite_datasets/_collate.py,sha256=pwUnmrbJH5olFjSwF-ZkGdfopTWUUlwmq0d5KzERcy8,4052
+maite_datasets/_fileio.py,sha256=7S-hF3xU60AdcsPsfYR7rjbeGZUlv3JjGEZhGJOxGYU,5622
+maite_datasets/_reader.py,sha256=tJqsjfXaK-mrs0Ed4BktombFMmNwCur35W7tuYCflKM,5569
+maite_datasets/_validate.py,sha256=Uokbolmv1uSv98sph44HON0HEieeK3s2mqbPMP1d5xs,6948
+maite_datasets/protocols.py,sha256=YGXb-WxlneXdIQBfBy5OdbylHSVfM-RBXeGvpiWwfLU,607
+maite_datasets/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maite_datasets/image_classification/__init__.py,sha256=pcZojkdsiMoLgY4mKjoQY6WyEwiGYHxNrAGpnvn3zsY,308
+maite_datasets/image_classification/_cifar10.py,sha256=rrkJZ70NBYOSGxligXyakVxNOyGAglN6PaGQazuWNO4,8453
+maite_datasets/image_classification/_mnist.py,sha256=9isgdi-YXgs6nXoh1j8uOgh4_sIhBIky72Vyl866rTE,8192
+maite_datasets/image_classification/_ships.py,sha256=nWhte8592lpybhQCCdgT36LnuMQ0PRJWlDxT5-IPUtk,5137
+maite_datasets/object_detection/__init__.py,sha256=171KT_X6I4YGy18G240N_-ZsKvXJ6YqcBDzkhTiBj2E,587
+maite_datasets/object_detection/_antiuav.py,sha256=B20JrbouDM1o5f1ct9Zfbkks8NaVqYrxu5x-rBZvGx8,8265
+maite_datasets/object_detection/_coco.py,sha256=3abRQJ9ATcZOeqK-4pnMfr-pv7aGcRum88SRlLLXTzk,10309
+maite_datasets/object_detection/_milco.py,sha256=brxxYs5ak0vEpOSd2IW5AMMVkuadVmXCJBFPvXTmNlo,7928
+maite_datasets/object_detection/_seadrone.py,sha256=JdHL0eRZoe7pXVInOq5Xpnz3-vgeBxbO25oTYgGZ44o,271213
+maite_datasets/object_detection/_voc.py,sha256=vgRn-sa_r2-hxwpM3veRZQMcWyqJz9OGalABOccZeow,19589
+maite_datasets/object_detection/_yolo.py,sha256=Luojzhanh6AK949910jN0yTpy8zwF5_At6nThj3Zw9Q,11867
+maite_datasets/wrappers/__init__.py,sha256=6uI0ztOB2IlMWln9JkVke4OhU2HQ8i6YCaCNq_q5qb0,225
+maite_datasets/wrappers/_torch.py,sha256=dmY6nSyLyVPOzpOE4BDTyOomWdFpN0x5dmH3XUzNetc,4588
+maite_datasets-0.0.6.dist-info/METADATA,sha256=cmDnRwPTu1xWbFIpnNQ0jmhEI7XTu6CQ3cm18y0dMDk,5505
+maite_datasets-0.0.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+maite_datasets-0.0.6.dist-info/licenses/LICENSE,sha256=6h3J3R-ajGHh_isDSftzS5_jJjB9HH4TaI0vU-VscaY,1082
+maite_datasets-0.0.6.dist-info/RECORD,,

maite_datasets/_mixin/_numpy.py

@@ -1,28 +0,0 @@
-from __future__ import annotations
-
-__all__ = []
-
-from typing import Any
-
-import numpy as np
-from numpy.typing import NDArray
-from PIL import Image
-
-from maite_datasets._base import BaseDatasetMixin
-
-
-class BaseDatasetNumpyMixin(BaseDatasetMixin[NDArray[np.number[Any]]]):
-    def _as_array(self, raw: list[Any]) -> NDArray[np.number[Any]]:
-        return np.asarray(raw)
-
-    def _one_hot_encode(self, value: int | list[int]) -> NDArray[np.number[Any]]:
-        if isinstance(value, int):
-            encoded = np.zeros(len(self.index2label))
-            encoded[value] = 1
-        else:
-            encoded = np.zeros((len(value), len(self.index2label)))
-            encoded[np.arange(len(value)), value] = 1
-        return encoded
-
-    def _read_file(self, path: str) -> NDArray[np.number[Any]]:
-        return np.array(Image.open(path)).transpose(2, 0, 1)

maite_datasets/_mixin/_torch.py

@@ -1,28 +0,0 @@
-from __future__ import annotations
-
-__all__ = []
-
-from typing import Any
-
-import numpy as np
-import torch
-from PIL import Image
-
-from maite_datasets._base import BaseDatasetMixin
-
-
-class BaseDatasetTorchMixin(BaseDatasetMixin[torch.Tensor]):
-    def _as_array(self, raw: list[Any]) -> torch.Tensor:
-        return torch.as_tensor(raw)
-
-    def _one_hot_encode(self, value: int | list[int]) -> torch.Tensor:
-        if isinstance(value, int):
-            encoded = torch.zeros(len(self.index2label))
-            encoded[value] = 1
-        else:
-            encoded = torch.zeros((len(value), len(self.index2label)))
-            encoded[torch.arange(len(value)), value] = 1
-        return encoded
-
-    def _read_file(self, path: str) -> torch.Tensor:
-        return torch.as_tensor(np.array(Image.open(path)).transpose(2, 0, 1))

maite_datasets/_protocols.py

@@ -1,217 +0,0 @@
-"""
-Common type protocols used for interoperability.
-"""
-
-from collections.abc import Iterator
-import sys
-from typing import (
-    Any,
-    Generic,
-    Protocol,
-    TypeAlias,
-    TypedDict,
-    TypeVar,
-    runtime_checkable,
-)
-
-import numpy.typing
-from typing_extensions import NotRequired, ReadOnly, Required
-
-if sys.version_info >= (3, 10):
-    from typing import TypeAlias
-else:
-    from typing_extensions import TypeAlias
-
-
-ArrayLike: TypeAlias = numpy.typing.ArrayLike
-"""
-Type alias for a `Union` representing objects that can be coerced into an array.
-
-See Also
---------
-`NumPy ArrayLike <https://numpy.org/doc/stable/reference/typing.html#numpy.typing.ArrayLike>`_
-"""
-
-
-@runtime_checkable
-class Array(Protocol):
-    """
-    Protocol for interoperable array objects.
-
-    Supports common array representations with popular libraries like
-    PyTorch, Tensorflow and JAX, as well as NumPy arrays.
-    """
-
-    @property
-    def shape(self) -> tuple[int, ...]: ...
-    def __array__(self) -> Any: ...
-    def __getitem__(self, key: Any, /) -> Any: ...
-    def __iter__(self) -> Iterator[Any]: ...
-    def __len__(self) -> int: ...
-
-
-_T = TypeVar("_T")
-_T_co = TypeVar("_T_co", covariant=True)
-_T_cn = TypeVar("_T_cn", contravariant=True)
-
-
-class DatasetMetadata(TypedDict, total=False):
-    """
-    Dataset level metadata required for all `AnnotatedDataset` classes.
-
-    Attributes
-    ----------
-    id : Required[str]
-        A unique identifier for the dataset
-    index2label : NotRequired[dict[int, str]]
-        A lookup table converting label value to class name
-    """
-
-    id: Required[ReadOnly[str]]
-    index2label: NotRequired[ReadOnly[dict[int, str]]]
-
-
-class DatumMetadata(TypedDict, total=False):
-    """
-    Datum level metadata required for all `AnnotatedDataset` classes.
-
-    Attributes
-    ----------
-    id : Required[str]
-        A unique identifier for the datum
-    """
-
-    id: Required[ReadOnly[str]]
-
-
-@runtime_checkable
-class Dataset(Generic[_T_co], Protocol):
-    """
-    Protocol for a generic `Dataset`.
-
-    Methods
-    -------
-    __getitem__(index: int)
-        Returns datum at specified index.
-    __len__()
-        Returns dataset length.
-    """
-
-    def __getitem__(self, index: int, /) -> _T_co: ...
-    def __len__(self) -> int: ...
-
-
-@runtime_checkable
-class AnnotatedDataset(Dataset[_T_co], Generic[_T_co], Protocol):
-    """
-    Protocol for a generic `AnnotatedDataset`.
-
-    Attributes
-    ----------
-    metadata : :class:`.DatasetMetadata` or derivatives.
-
-    Methods
-    -------
-    __getitem__(index: int)
-        Returns datum at specified index.
-    __len__()
-        Returns dataset length.
-
-    Notes
-    -----
-    Inherits from :class:`.Dataset`.
-    """
-
-    @property
-    def metadata(self) -> DatasetMetadata: ...
-
-
-# ========== IMAGE CLASSIFICATION DATASETS ==========
-
-
-ImageClassificationDatum: TypeAlias = tuple[ArrayLike, ArrayLike, DatumMetadata]
-"""
-Type alias for an image classification datum tuple.
-
-- :class:`ArrayLike` of shape (C, H, W) - Image data in channel, height, width format.
-- :class:`ArrayLike` of shape (N,) - Class label as one-hot encoded ground-truth or prediction confidences.
-- dict[str, Any] - Datum level metadata.
-"""
-
-
-ImageClassificationDataset: TypeAlias = AnnotatedDataset[ImageClassificationDatum]
-"""
-Type alias for an :class:`AnnotatedDataset` of :class:`ImageClassificationDatum` elements.
-"""
-
-# ========== OBJECT DETECTION DATASETS ==========
-
-
-@runtime_checkable
-class ObjectDetectionTarget(Protocol):
-    """
-    Protocol for targets in an Object Detection dataset.
-
-    Attributes
-    ----------
-    boxes : :class:`ArrayLike` of shape (N, 4)
-    labels : :class:`ArrayLike` of shape (N,)
-    scores : :class:`ArrayLike` of shape (N, M)
-    """
-
-    @property
-    def boxes(self) -> ArrayLike: ...
-
-    @property
-    def labels(self) -> ArrayLike: ...
-
-    @property
-    def scores(self) -> ArrayLike: ...
-
-
-ObjectDetectionDatum: TypeAlias = tuple[ArrayLike, ObjectDetectionTarget, DatumMetadata]
-"""
-Type alias for an object detection datum tuple.
-
-- :class:`ArrayLike` of shape (C, H, W) - Image data in channel, height, width format.
-- :class:`ObjectDetectionTarget` - Object detection target information for the image.
-- dict[str, Any] - Datum level metadata.
-"""
-
-
-ObjectDetectionDataset: TypeAlias = AnnotatedDataset[ObjectDetectionDatum]
-"""
-Type alias for an :class:`AnnotatedDataset` of :class:`ObjectDetectionDatum` elements.
-"""
-
-
-# ========== TRANSFORM ==========
-
-
-@runtime_checkable
-class Transform(Generic[_T], Protocol):
-    """
-    Protocol defining a transform function.
-
-    Requires a `__call__` method that returns transformed data.
-
-    Example
-    -------
-    >>> from typing import Any
-    >>> from numpy.typing import NDArray
-
-    >>> class MyTransform:
-    ...     def __init__(self, divisor: float) -> None:
-    ...         self.divisor = divisor
-    ...
-    ...     def __call__(self, data: NDArray[Any], /) -> NDArray[Any]:
-    ...         return data / self.divisor
-
-    >>> my_transform = MyTransform(divisor=255.0)
-    >>> isinstance(my_transform, Transform)
-    True
-    >>> my_transform(np.array([1, 2, 3]))
-    array([0.004, 0.008, 0.012])
-    """
-
-    def __call__(self, data: _T, /) -> _T: ...

maite_datasets/_reader/__init__.py

@@ -1,6 +0,0 @@
-"""
-Dataset readers for common computer vision dataset formats.
-
-This module provides standardized readers that for loading datasets
-from directory structures.
-"""

maite_datasets/_reader/_factory.py

@@ -1,64 +0,0 @@
-from __future__ import annotations
-
-import logging
-from pathlib import Path
-
-from maite_datasets._reader._base import BaseDatasetReader
-from maite_datasets._reader._yolo import YOLODatasetReader
-from maite_datasets._reader._coco import COCODatasetReader
-
-_logger = logging.getLogger(__name__)
-
-
-def create_dataset_reader(dataset_path: str | Path, format_hint: str | None = None) -> BaseDatasetReader:
-    """
-    Factory function to create appropriate dataset reader based on directory structure.
-
-    Parameters
-    ----------
-    dataset_path : str or Path
-        Root directory containing dataset files
-    format_hint : str or None, default None
-        Format hint ("coco" or "yolo"). If None, auto-detects based on file structure
-
-    Returns
-    -------
-    BaseDatasetReader
-        Appropriate reader instance for the detected format
-
-    Raises
-    ------
-    ValueError
-        If format cannot be determined or is unsupported
-    """
-    dataset_path = Path(dataset_path)
-
-    if format_hint:
-        format_hint = format_hint.lower()
-        if format_hint == "coco":
-            return COCODatasetReader(dataset_path)
-        elif format_hint == "yolo":
-            return YOLODatasetReader(dataset_path)
-        else:
-            raise ValueError(f"Unsupported format hint: {format_hint}")
-
-    # Auto-detect format
-    has_annotations_json = (dataset_path / "annotations.json").exists()
-    has_labels_dir = (dataset_path / "labels").exists()
-
-    if has_annotations_json and not has_labels_dir:
-        _logger.info(f"Detected COCO format for {dataset_path}")
-        return COCODatasetReader(dataset_path)
-    elif has_labels_dir and not has_annotations_json:
-        _logger.info(f"Detected YOLO format for {dataset_path}")
-        return YOLODatasetReader(dataset_path)
-    elif has_annotations_json and has_labels_dir:
-        raise ValueError(
-            f"Ambiguous format in {dataset_path}: both annotations.json and labels/ exist. "
-            "Use format_hint parameter to specify format."
-        )
-    else:
-        raise ValueError(
-            f"Cannot detect dataset format in {dataset_path}. "
-            "Expected either annotations.json (COCO) or labels/ directory (YOLO)."
-        )

maite_datasets/_types.py

@@ -1,50 +0,0 @@
-from __future__ import annotations
-
-__all__ = []
-
-from dataclasses import dataclass
-from typing import Generic, TypedDict, TypeVar
-
-from typing_extensions import NotRequired, Required
-
-_T_co = TypeVar("_T_co", covariant=True)
-
-
-class Dataset(Generic[_T_co]):
-    """Abstract generic base class for PyTorch style Dataset"""
-
-    def __getitem__(self, index: int) -> _T_co: ...
-    def __add__(self, other: Dataset[_T_co]) -> Dataset[_T_co]: ...
-
-
-class DatasetMetadata(TypedDict):
-    id: Required[str]
-    index2label: NotRequired[dict[int, str]]
-    split: NotRequired[str]
-
-
-class DatumMetadata(TypedDict, total=False):
-    id: Required[str]
-
-
-_TDatum = TypeVar("_TDatum")
-_TArray = TypeVar("_TArray")
-
-
-class AnnotatedDataset(Dataset[_TDatum]):
-    metadata: DatasetMetadata
-
-    def __len__(self) -> int: ...
-
-
-class ImageClassificationDataset(AnnotatedDataset[tuple[_TArray, _TArray, DatumMetadata]]): ...
-
-
-@dataclass
-class ObjectDetectionTarget(Generic[_TArray]):
-    boxes: _TArray
-    labels: _TArray
-    scores: _TArray
-
-
-class ObjectDetectionDataset(AnnotatedDataset[tuple[_TArray, ObjectDetectionTarget[_TArray], DatumMetadata]]): ...