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

maite_datasets-0.0.7.dist-info/METADATA

@@ -0,0 +1,181 @@
+Metadata-Version: 2.4
+Name: maite-datasets
+Version: 0.0.7
+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
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Pytest
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+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
+Requires-Dist: typing-extensions>=4.12
+Provides-Extra: tqdm
+Requires-Dist: tqdm>=4.66; extra == 'tqdm'
+Description-Content-Type: text/markdown
+
+# MAITE Datasets
+
+MAITE Datasets are a collection of public datasets wrapped in a [MAITE](https://mit-ll-ai-technology.github.io/maite/) compliant format.
+
+## Installation
+
+To install and use `maite-datasets` you can use pip:
+
+```bash
+pip install maite-datasets
+```
+
+For status bar indicators when downloading, you can include the extra `tqdm` when installing:
+
+```bash
+pip install maite-datasets[tqdm]
+```
+
+## Available Downloadable Datasets
+
+| Task           | Dataset          | Description                                                         |
+|----------------|------------------|---------------------------------------------------------------------|
+| Classification | CIFAR10          | [CIFAR10](https://www.cs.toronto.edu/~kriz/cifar.html) dataset.     |
+| Classification | MNIST            | A dataset of hand-written digits.                                   |
+| Classification | Ships            | A dataset that focuses on identifying ships from satellite images.  |
+| Detection      | AntiUAVDetection | A UAV detection dataset in natural images with varying backgrounds. |
+| Detection      | MILCO            | A side-scan sonar dataset focused on mine-like object detection.    |
+| 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
+
+Here is an example of how to import MNIST for usage with your workflow.
+
+```python
+>>> from maite_datasets.image_classification import MNIST
+
+>>> mnist = MNIST(root="data", download=True)
+>>> print(mnist)
+MNIST Dataset
+-------------
+    Corruption: None
+    Transforms: []
+    Image_set: train
+    Metadata: {'id': 'MNIST_train', 'index2label': {0: 'zero', 1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five', 6: 'six', 7: 'seven', 8: 'eight', 9: 'nine'}, 'split': 'train'}
+    Path: /home/user/maite-datasets/data/mnist
+    Size: 60000
+
+>>> print("tuple("+", ".join([str(type(t)) for t in mnist[0]])+")")
+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.
+
+### Torchvision
+
+`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)
+```
+
+## Dataset Adapters
+
+Adapters provide a way to read in datasets from other popular formats.
+
+### Huggingface
+
+Hugging face datasets can be adapted into MAITE compliant format using the `from_huggingface` adapter.
+
+```python
+>>> from datasets import load_dataset
+>>> from maite_datasets.adapters import from_huggingface
+
+>>> cppe5 = load_dataset("cppe-5")
+>>> m_cppe5 = from_huggingface(cppe5["train"])
+>>> print(m_cppe5)
+HFObjectDetection Dataset
+-------------------------
+    Source: Dataset({
+    features: ['image_id', 'image', 'width', 'height', 'objects'],
+    num_rows: 1000
+})
+    Metadata: {'id': 'cppe-5', 'index2label': {0: 'Coverall', 1: 'Face_Shield', 2: 'Gloves', 3: 'Goggles', 4: 'Mask'}, 'description': '', 'citation': '', 'homepage': '', 'license': '', 'features': {'image_id': Value('int64'), 'image': Image(mode=None, decode=True), 'width': Value('int32'), 'height': Value('int32'), 'objects': {'id': List(Value('int64')), 'area': List(Value('int64')), 'bbox': List(List(Value('float32'), length=4)), 'category': List(ClassLabel(names=['Coverall', 'Face_Shield', 'Gloves', 'Goggles', 'Mask']))}}, 'post_processed': None, 'supervised_keys': None, 'builder_name': 'parquet', 'dataset_name': 'cppe-5', 'config_name': 'default', 'version': 0.0.0, 'splits': {'train': SplitInfo(name='train', num_bytes=240478590, num_examples=1000, shard_lengths=None, dataset_name='cppe-5'), 'test': SplitInfo(name='test', num_bytes=4172706, num_examples=29, shard_lengths=None, dataset_name='cppe-5')}, 'download_checksums': {'hf://datasets/cppe-5@66f6a5efd474e35bd7cb94bf15dea27d4c6ad3f8/data/train-00000-of-00001.parquet': {'num_bytes': 237015519, 'checksum': None}, 'hf://datasets/cppe-5@66f6a5efd474e35bd7cb94bf15dea27d4c6ad3f8/data/test-00000-of-00001.parquet': {'num_bytes': 4137134, 'checksum': None}}, 'download_size': 241152653, 'post_processing_size': None, 'dataset_size': 244651296, 'size_in_bytes': 485803949}
+
+>>> image = m_cppe5[0][0]
+>>> print(f"type={image.__class__.__name__}, shape={image.shape}")
+type=ndarray, shape=(3, 663, 943)
+
+>>> target = m_cppe5[0][1]
+>>> print(f"box={target.boxes[0]}, label={target.labels[0]}")
+box=[302.0, 109.0, 73.0, 52.0], label=4
+
+>>> print(m_cppe5[0][2])
+{'id': [114, 115, 116, 117], 'image_id': 15, 'width': 943, 'height': 663, 'area': [3796, 1596, 152768, 81002]}
+```
+
+## Additional Information
+
+For more information on the MAITE protocol, check out their [documentation](https://mit-ll-ai-technology.github.io/maite/).
+
+## Acknowledgement
+
+### CDAO Funding Acknowledgement
+
+This material is based upon work supported by the Chief Digital and Artificial
+Intelligence Office under Contract No. W519TC-23-9-2033. The views and
+conclusions contained herein are those of the author(s) and should not be
+interpreted as necessarily representing the official policies or endorsements,
+either expressed or implied, of the U.S. Government.

maite_datasets-0.0.7.dist-info/RECORD

@@ -0,0 +1,28 @@
+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=8NPD2AdYXiz2i9TQwS_kdpboFeYMad3G7peuh2c9GZc,2153
+maite_datasets/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maite_datasets/adapters/__init__.py,sha256=PDMdvRqLVS7x6ghJ_xUBD5Ebq5HrV5k3p4TqK2_6Gt8,191
+maite_datasets/adapters/_huggingface.py,sha256=bmAz9Pssqfma1hzgTM4wtoLKnWAozkxNUzREGBYYTyM,16179
+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=nPWeBtam6EPZf9BGbrFqKlyWfyzOpX_zpLFZBTnA2Vg,4458
+maite_datasets-0.0.7.dist-info/METADATA,sha256=L4UmetVfmJBFDtDWo2yElwBt47VY__euzWgDgaWgkzs,7845
+maite_datasets-0.0.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+maite_datasets-0.0.7.dist-info/licenses/LICENSE,sha256=6h3J3R-ajGHh_isDSftzS5_jJjB9HH4TaI0vU-VscaY,1082
+maite_datasets-0.0.7.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]]): ...

maite_datasets/object_detection/_voc_torch.py

@@ -1,65 +0,0 @@
-from __future__ import annotations
-
-__all__ = []
-
-from torch import Tensor
-
-from maite_datasets._base import BaseODDataset
-from maite_datasets._types import ObjectDetectionTarget
-from maite_datasets._mixin._torch import BaseDatasetTorchMixin
-from maite_datasets.object_detection._voc import BaseVOCDataset
-
-
-class VOCDetectionTorch(
-    BaseVOCDataset[Tensor, ObjectDetectionTarget[Tensor]],
-    BaseODDataset[Tensor, list[str], str],
-    BaseDatasetTorchMixin,
-):
-    """
-    `Pascal VOC <http://host.robots.ox.ac.uk/pascal/VOC/>`_ Detection Dataset as PyTorch tensors.
-
-    Parameters
-    ----------
-    root : str or pathlib.Path
-        Because of the structure of the PASCAL VOC datasets, the root needs to be one of 4 folders.
-        1) Directory containing the year of the **already downloaded** dataset (i.e. .../VOCdevkit/VOC2012 <-)
-        2) Directory to the VOCdevkit folder of the **already downloaded** dataset (i.e. .../VOCdevkit <- /VOC2012)
-        3) Directory to the folder one level up from the VOCdevkit folder,
-        data **may** or **may not** be already downloaded (i.e. ... <- /VOCdevkit/VOC2012)
-        4) Directory to where you would like the dataset to be downloaded
-    image_set : "train", "val", "test", or "base", default "train"
-        If "test", then dataset year must be "2007" or "2012". Note that the 2012 test set does not contain annotations.
-        If "base", then the combined dataset of "train" and "val" is returned.
-    year : "2007", "2008", "2009", "2010", "2011" or "2012", default "2012"
-        The dataset year.
-    transforms : Transform, Sequence[Transform] or None, default None
-        Transform(s) to apply to the data.
-    download : bool, default False
-        If True, downloads the dataset from the internet and puts it in root directory.
-        Class checks to see if data is already downloaded to ensure it does not create a duplicate download.
-    verbose : bool, default False
-        If True, outputs print statements.
-
-    Attributes
-    ----------
-    path : pathlib.Path
-        Location of the folder containing the data.
-    year : "2007", "2008", "2009", "2010", "2011" or "2012"
-        The selected dataset year.
-    image_set : "train", "val", "test" or "base"
-        The selected image set from the dataset.
-    index2label : dict[int, str]
-        Dictionary which translates from class integers to the associated class strings.
-    label2index : dict[str, int]
-        Dictionary which translates from class strings to the associated class integers.
-    metadata : DatasetMetadata
-        Typed dictionary containing dataset metadata, such as `id` which returns the dataset class name.
-    transforms : Sequence[Transform]
-        The transforms to be applied to the data.
-    size : int
-        The size of the dataset.
-
-    Note
-    ----
-    Data License: `Flickr Terms of Use <http://www.flickr.com/terms.gne?legacy=1>`_
-    """