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

maite_datasets/__init__.py

@@ -1,11 +1,9 @@
 """Module for MAITE compliant Computer Vision datasets."""
 
 from maite_datasets._builder import to_image_classification_dataset, to_object_detection_dataset
-from maite_datasets._collate import collate_as_torch, collate_as_numpy, collate_as_list
+from maite_datasets._collate import collate_as_list, collate_as_numpy, collate_as_torch
+from maite_datasets._reader import create_dataset_reader
 from maite_datasets._validate import validate_dataset
-from maite_datasets._reader._factory import create_dataset_reader
-from maite_datasets._reader._coco import COCODatasetReader
-from maite_datasets._reader._yolo import YOLODatasetReader
 
 __all__ = [
     "collate_as_list",
@@ -15,6 +13,4 @@ __all__ = [
     "to_image_classification_dataset",
     "to_object_detection_dataset",
     "validate_dataset",
-    "COCODatasetReader",
-    "YOLODatasetReader",
 ]

maite_datasets/_base.py

@@ -2,23 +2,24 @@ from __future__ import annotations
 
 __all__ = []
 
+import inspect
+import warnings
 from abc import abstractmethod
+from collections import namedtuple
+from collections.abc import Iterator, Sequence
 from pathlib import Path
-from typing import Any, Generic, Iterator, Literal, NamedTuple, Sequence, TypeVar, cast
+from typing import Any, Callable, Generic, Literal, NamedTuple, TypeVar, cast
 
 import numpy as np
+from maite.protocols import DatasetMetadata, DatumMetadata
+from numpy.typing import NDArray
+from PIL import Image
 
 from maite_datasets._fileio import _ensure_exists
-from maite_datasets._protocols import Array, Transform
-from maite_datasets._types import (
-    AnnotatedDataset,
-    DatasetMetadata,
-    DatumMetadata,
-    ImageClassificationDataset,
-    ObjectDetectionDataset,
-    ObjectDetectionTarget,
-)
+from maite_datasets.protocols import Array
 
+_T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)
 _TArray = TypeVar("_TArray", bound=Array)
 _TTarget = TypeVar("_TTarget")
 _TRawTarget = TypeVar(
@@ -30,16 +31,7 @@ _TRawTarget = TypeVar(
 _TAnnotation = TypeVar("_TAnnotation", int, str, tuple[list[int], list[list[float]]])
 
 
-def _to_datum_metadata(index: int, metadata: dict[str, Any]) -> DatumMetadata:
-    _id = metadata.pop("id", index)
-    return DatumMetadata(id=_id, **metadata)
-
-
-class DataLocation(NamedTuple):
-    url: str
-    filename: str
-    md5: bool
-    checksum: str
+ObjectDetectionTarget = namedtuple("ObjectDetectionTarget", ["boxes", "labels", "scores"])
 
 
 class BaseDatasetMixin(Generic[_TArray]):
@@ -50,8 +42,99 @@ class BaseDatasetMixin(Generic[_TArray]):
     def _read_file(self, path: str) -> _TArray: ...
 
 
-class BaseDataset(
-    AnnotatedDataset[tuple[_TArray, _TTarget, DatumMetadata]],
+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 BaseDataset(Dataset[tuple[_TArray, _TTarget, DatumMetadata]]):
+    metadata: DatasetMetadata
+
+    def __init__(
+        self,
+        transforms: Callable[[_TArray], _TArray]
+        | Callable[
+            [tuple[_TArray, _TTarget, DatumMetadata]],
+            tuple[_TArray, _TTarget, DatumMetadata],
+        ]
+        | Sequence[
+            Callable[[_TArray], _TArray]
+            | Callable[
+                [tuple[_TArray, _TTarget, DatumMetadata]],
+                tuple[_TArray, _TTarget, DatumMetadata],
+            ]
+        ]
+        | None,
+    ) -> None:
+        self.transforms: Sequence[
+            Callable[
+                [tuple[_TArray, _TTarget, DatumMetadata]],
+                tuple[_TArray, _TTarget, DatumMetadata],
+            ]
+        ] = []
+        transforms = transforms if isinstance(transforms, Sequence) else [transforms] if transforms else []
+        for transform in transforms:
+            sig = inspect.signature(transform)
+            if len(sig.parameters) != 1:
+                warnings.warn(f"Dropping unrecognized transform: {str(transform)}")
+            elif "tuple" in str(sig.parameters.values()):
+                transform = cast(
+                    Callable[
+                        [tuple[_TArray, _TTarget, DatumMetadata]],
+                        tuple[_TArray, _TTarget, DatumMetadata],
+                    ],
+                    transform,
+                )
+                self.transforms.append(transform)
+            else:
+                transform = cast(Callable[[_TArray], _TArray], transform)
+                self.transforms.append(self._wrap_transform(transform))
+
+    def _wrap_transform(
+        self, transform: Callable[[_TArray], _TArray]
+    ) -> Callable[
+        [tuple[_TArray, _TTarget, DatumMetadata]],
+        tuple[_TArray, _TTarget, DatumMetadata],
+    ]:
+        def wrapper(
+            datum: tuple[_TArray, _TTarget, DatumMetadata],
+        ) -> tuple[_TArray, _TTarget, DatumMetadata]:
+            image, target, metadata = datum
+            return (transform(image), target, metadata)
+
+        return wrapper
+
+    def _transform(self, datum: tuple[_TArray, _TTarget, DatumMetadata]) -> tuple[_TArray, _TTarget, DatumMetadata]:
+        """Function to transform the image prior to returning based on parameters passed in."""
+        for transform in self.transforms:
+            datum = transform(datum)
+        return datum
+
+    def __len__(self) -> int: ...
+
+    def __str__(self) -> str:
+        nt = "\n    "
+        title = f"{self.__class__.__name__.replace('Dataset', '')} Dataset"
+        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("_")
+        ]
+        return f"{title}\n{sep}{nt}{nt.join(attrs)}"
+
+
+class DataLocation(NamedTuple):
+    url: str
+    filename: str
+    md5: bool
+    checksum: str
+
+
+class BaseDownloadedDataset(
+    BaseDataset[_TArray, _TTarget],
     Generic[_TArray, _TTarget, _TRawTarget, _TAnnotation],
 ):
     """
@@ -72,13 +155,24 @@ class BaseDataset(
         self,
         root: str | Path,
         image_set: Literal["train", "val", "test", "operational", "base"] = "train",
-        transforms: Transform[_TArray] | Sequence[Transform[_TArray]] | None = None,
+        transforms: Callable[[_TArray], _TArray]
+        | Callable[
+            [tuple[_TArray, _TTarget, DatumMetadata]],
+            tuple[_TArray, _TTarget, DatumMetadata],
+        ]
+        | Sequence[
+            Callable[[_TArray], _TArray]
+            | Callable[
+                [tuple[_TArray, _TTarget, DatumMetadata]],
+                tuple[_TArray, _TTarget, DatumMetadata],
+            ]
+        ]
+        | None = None,
         download: bool = False,
         verbose: bool = False,
     ) -> None:
+        super().__init__(transforms)
         self._root: Path = root.absolute() if isinstance(root, Path) else Path(root).absolute()
-        transforms = transforms if transforms is not None else []
-        self.transforms: Sequence[Transform[_TArray]] = transforms if isinstance(transforms, Sequence) else [transforms]
         self.image_set = image_set
         self._verbose = verbose
 
@@ -91,9 +185,11 @@ class BaseDataset(
         self._label2index = {v: k for k, v in self.index2label.items()}
 
         self.metadata: DatasetMetadata = DatasetMetadata(
-            id=self._unique_id(),
-            index2label=self.index2label,
-            split=self.image_set,
+            **{
+                "id": self._unique_id(),
+                "index2label": self.index2label,
+                "split": self.image_set,
+            }
         )
 
         # Load the data
@@ -101,13 +197,6 @@ class BaseDataset(
         self._filepaths, self._targets, self._datum_metadata = self._load_data()
         self.size: int = len(self._filepaths)
 
-    def __str__(self) -> str:
-        nt = "\n    "
-        title = f"{self.__class__.__name__} Dataset"
-        sep = "-" * len(title)
-        attrs = [f"{k.capitalize()}: {v}" for k, v in self.__dict__.items() if not k.startswith("_")]
-        return f"{title}\n{sep}{nt}{nt.join(attrs)}"
-
     @property
     def label2index(self) -> dict[str, int]:
         return self._label2index
@@ -148,20 +237,18 @@ class BaseDataset(
     @abstractmethod
     def _load_data_inner(self) -> tuple[list[str], _TRawTarget, dict[str, Any]]: ...
 
-    def _transform(self, image: _TArray) -> _TArray:
-        """Function to transform the image prior to returning based on parameters passed in."""
-        for transform in self.transforms:
-            image = transform(image)
-        return image
+    def _to_datum_metadata(self, index: int, metadata: dict[str, Any]) -> DatumMetadata:
+        _id = metadata.pop("id", index)
+        return DatumMetadata(id=_id, **metadata)
 
     def __len__(self) -> int:
         return self.size
 
 
 class BaseICDataset(
-    BaseDataset[_TArray, _TArray, list[int], int],
+    BaseDownloadedDataset[_TArray, _TArray, list[int], int],
     BaseDatasetMixin[_TArray],
-    ImageClassificationDataset[_TArray],
+    BaseDataset[_TArray, _TArray],
 ):
     """
     Base class for image classification datasets.
@@ -184,17 +271,16 @@ class BaseICDataset(
         score = self._one_hot_encode(label)
         # Get the image
         img = self._read_file(self._filepaths[index])
-        img = self._transform(img)
 
         img_metadata = {key: val[index] for key, val in self._datum_metadata.items()}
 
-        return img, score, _to_datum_metadata(index, img_metadata)
+        return self._transform((img, score, self._to_datum_metadata(index, img_metadata)))
 
 
 class BaseODDataset(
-    BaseDataset[_TArray, ObjectDetectionTarget[_TArray], _TRawTarget, _TAnnotation],
+    BaseDownloadedDataset[_TArray, ObjectDetectionTarget, _TRawTarget, _TAnnotation],
     BaseDatasetMixin[_TArray],
-    ObjectDetectionDataset[_TArray],
+    BaseDataset[_TArray, ObjectDetectionTarget],
 ):
     """
     Base class for object detection datasets.
@@ -202,7 +288,7 @@ class BaseODDataset(
 
     _bboxes_per_size: bool = False
 
-    def __getitem__(self, index: int) -> tuple[_TArray, ObjectDetectionTarget[_TArray], DatumMetadata]:
+    def __getitem__(self, index: int) -> tuple[_TArray, ObjectDetectionTarget, DatumMetadata]:
         """
         Args
         ----
@@ -211,7 +297,7 @@ class BaseODDataset(
 
         Returns
         -------
-        tuple[TArray, ObjectDetectionTarget[TArray], DatumMetadata]
+        tuple[TArray, ObjectDetectionTarget, DatumMetadata]
             Image, target, datum_metadata - target.boxes returns boxes in x0, y0, x1, y1 format
         """
         # Grab the bounding boxes and labels from the annotations
@@ -220,17 +306,49 @@ class BaseODDataset(
         # Get the image
         img = self._read_file(self._filepaths[index])
         img_size = img.shape
-        img = self._transform(img)
         # Adjust labels if necessary
         if self._bboxes_per_size and boxes:
-            boxes = boxes * np.array([[img_size[1], img_size[2], img_size[1], img_size[2]]])
+            boxes = boxes * np.asarray([[img_size[1], img_size[2], img_size[1], img_size[2]]])
         # Create the Object Detection Target
         target = ObjectDetectionTarget(self._as_array(boxes), self._as_array(labels), self._one_hot_encode(labels))
 
         img_metadata = {key: val[index] for key, val in self._datum_metadata.items()}
         img_metadata = img_metadata | additional_metadata
 
-        return img, target, _to_datum_metadata(index, img_metadata)
+        return self._transform((img, target, self._to_datum_metadata(index, img_metadata)))
 
     @abstractmethod
     def _read_annotations(self, annotation: _TAnnotation) -> tuple[list[list[float]], list[int], dict[str, Any]]: ...
+
+
+NumpyArray = NDArray[np.floating[Any]] | NDArray[np.integer[Any]]
+
+
+class BaseDatasetNumpyMixin(BaseDatasetMixin[NumpyArray]):
+    def _as_array(self, raw: list[Any]) -> NumpyArray:
+        return np.asarray(raw)
+
+    def _one_hot_encode(self, value: int | list[int]) -> NumpyArray:
+        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) -> NumpyArray:
+        return np.array(Image.open(path)).transpose(2, 0, 1)
+
+
+NumpyImageTransform = Callable[[NumpyArray], NumpyArray]
+NumpyImageClassificationDatumTransform = Callable[
+    [tuple[NumpyArray, NumpyArray, DatumMetadata]],
+    tuple[NumpyArray, NumpyArray, DatumMetadata],
+]
+NumpyObjectDetectionDatumTransform = Callable[
+    [tuple[NumpyArray, ObjectDetectionTarget, DatumMetadata]],
+    tuple[NumpyArray, ObjectDetectionTarget, DatumMetadata],
+]
+NumpyImageClassificationTransform = NumpyImageTransform | NumpyImageClassificationDatumTransform
+NumpyObjectDetectionTransform = NumpyImageTransform | NumpyObjectDetectionDatumTransform

maite_datasets/_builder.py

@@ -1,29 +1,24 @@
 from __future__ import annotations
 
-import numpy as np
-
 __all__ = []
 
+from collections.abc import Iterable, Sequence
 from typing import (
     Any,
     Generic,
-    Iterable,
     Literal,
-    Sequence,
     SupportsFloat,
     SupportsInt,
     TypeVar,
     cast,
 )
 
-from maite_datasets._protocols import (
-    Array,
-    ArrayLike,
-    DatasetMetadata,
-    ImageClassificationDataset,
-    ObjectDetectionDataset,
-    DatumMetadata,
-)
+import maite.protocols.image_classification as ic
+import maite.protocols.object_detection as od
+import numpy as np
+from maite.protocols import ArrayLike, DatasetMetadata, DatumMetadata
+
+from maite_datasets.protocols import Array
 
 
 def _ensure_id(index: int, metadata: dict[str, Any]) -> DatumMetadata:
@@ -97,6 +92,8 @@ _TLabels = TypeVar("_TLabels", Sequence[int], Sequence[Sequence[int]])
 
 
 class BaseAnnotatedDataset(Generic[_TLabels]):
+    metadata: DatasetMetadata
+
     def __init__(
         self,
         datum_type: Literal["ic", "od"],
@@ -112,16 +109,13 @@ class BaseAnnotatedDataset(Generic[_TLabels]):
         self._labels = labels
         self._metadata = metadata
         self._id = name or f"{len(self._images)}_image_{len(self._index2label)}_class_{datum_type}_dataset"
-
-    @property
-    def metadata(self) -> DatasetMetadata:
-        return DatasetMetadata(id=self._id, index2label=self._index2label)
+        self.metadata = DatasetMetadata(id=self._id, index2label=self._index2label)
 
     def __len__(self) -> int:
         return len(self._images)
 
 
-class CustomImageClassificationDataset(BaseAnnotatedDataset[Sequence[int]], ImageClassificationDataset):
+class CustomImageClassificationDataset(BaseAnnotatedDataset[Sequence[int]], ic.Dataset):
     def __init__(
         self,
         images: Array | Sequence[Array],
@@ -152,33 +146,34 @@ class CustomImageClassificationDataset(BaseAnnotatedDataset[Sequence[int]], Imag
         )
 
 
-class CustomObjectDetectionDataset(BaseAnnotatedDataset[Sequence[Sequence[int]]], ObjectDetectionDataset):
-    class ObjectDetectionTarget:
-        def __init__(
-            self,
-            labels: Sequence[int],
-            bboxes: Sequence[Sequence[float]],
-            class_count: int,
-        ) -> None:
-            self._labels = labels
-            self._bboxes = bboxes
-            one_hot = [[0.0] * class_count] * len(labels)
-            for i, label in enumerate(labels):
-                one_hot[i][label] = 1.0
-            self._scores = one_hot
-
-        @property
-        def labels(self) -> Sequence[int]:
-            return self._labels
-
-        @property
-        def boxes(self) -> Sequence[Sequence[float]]:
-            return self._bboxes
-
-        @property
-        def scores(self) -> Sequence[Sequence[float]]:
-            return self._scores
+class CustomObjectDetectionTarget:
+    def __init__(
+        self,
+        labels: Sequence[int],
+        bboxes: Sequence[Sequence[float]],
+        class_count: int,
+    ) -> None:
+        self._labels = labels
+        self._bboxes = bboxes
+        one_hot = [[0.0] * class_count] * len(labels)
+        for i, label in enumerate(labels):
+            one_hot[i][label] = 1.0
+        self._scores = one_hot
+
+    @property
+    def labels(self) -> Sequence[int]:
+        return self._labels
+
+    @property
+    def boxes(self) -> Sequence[Sequence[float]]:
+        return self._bboxes
 
+    @property
+    def scores(self) -> Sequence[Sequence[float]]:
+        return self._scores
+
+
+class CustomObjectDetectionDataset(BaseAnnotatedDataset[Sequence[Sequence[int]]], od.Dataset):
     def __init__(
         self,
         images: Array | Sequence[Array],
@@ -203,14 +198,10 @@ class CustomObjectDetectionDataset(BaseAnnotatedDataset[Sequence[Sequence[int]]]
             [np.asarray(box).tolist() if isinstance(box, Array) else box for box in bbox] for bbox in bboxes
         ]
 
-    @property
-    def metadata(self) -> DatasetMetadata:
-        return DatasetMetadata(id=self._id, index2label=self._index2label)
-
-    def __getitem__(self, idx: int, /) -> tuple[Array, ObjectDetectionTarget, DatumMetadata]:
+    def __getitem__(self, idx: int, /) -> tuple[Array, CustomObjectDetectionTarget, DatumMetadata]:
         return (
             self._images[idx],
-            self.ObjectDetectionTarget(self._labels[idx], self._bboxes[idx], len(self._classes)),
+            CustomObjectDetectionTarget(self._labels[idx], self._bboxes[idx], len(self._classes)),
             _ensure_id(idx, self._metadata[idx] if self._metadata is not None else {}),
         )
 
@@ -221,9 +212,9 @@ def to_image_classification_dataset(
     metadata: Sequence[dict[str, Any]] | dict[str, Sequence[Any]] | None,
     classes: Sequence[str] | None,
     name: str | None = None,
-) -> ImageClassificationDataset:
+) -> ic.Dataset:
     """
-    Helper function to create custom ImageClassificationDataset classes.
+    Helper function to create custom image classification Dataset classes.
 
     Parameters
     ----------
@@ -238,7 +229,7 @@ def to_image_classification_dataset(
 
     Returns
     -------
-    ImageClassificationDataset
+    Dataset
     """
     _validate_data("ic", images, labels, None, metadata)
     return CustomImageClassificationDataset(images, labels, _listify_metadata(metadata), classes, name)
@@ -251,9 +242,9 @@ def to_object_detection_dataset(
     metadata: Sequence[dict[str, Any]] | dict[str, Sequence[Any]] | None,
     classes: Sequence[str] | None,
     name: str | None = None,
-) -> ObjectDetectionDataset:
+) -> od.Dataset:
     """
-    Helper function to create custom ObjectDetectionDataset classes.
+    Helper function to create custom object detection Dataset classes.
 
     Parameters
     ----------
@@ -270,7 +261,7 @@ def to_object_detection_dataset(
 
     Returns
     -------
-    ObjectDetectionDataset
+    Dataset
     """
     _validate_data("od", images, labels, bboxes, metadata)
     return CustomObjectDetectionDataset(images, labels, bboxes, _listify_metadata(metadata), classes, name)

maite_datasets/_collate.py

@@ -7,16 +7,15 @@ from __future__ import annotations
 __all__ = []
 
 from collections.abc import Iterable, Sequence
-from typing import Any, TypeVar, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, TypeVar
 
 import numpy as np
+from maite.protocols import ArrayLike
 from numpy.typing import NDArray
 
 if TYPE_CHECKING:
     import torch
 
-from maite_datasets._protocols import ArrayLike
-
 T_in = TypeVar("T_in")
 T_tgt = TypeVar("T_tgt")
 T_md = TypeVar("T_md")

maite_datasets/{_reader/_base.py → _reader.py}

@@ -1,39 +1,19 @@
 from __future__ import annotations
 
-from abc import ABC, abstractmethod
 import logging
+from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import Any
-
-import numpy as np
+from typing import Any, Generic, TypeVar
 
-from maite_datasets._protocols import ArrayLike, ObjectDetectionDataset
+import maite.protocols.image_classification as ic
+import maite.protocols.object_detection as od
 
 _logger = logging.getLogger(__name__)
 
-
-class _ObjectDetectionTarget:
-    """Internal implementation of ObjectDetectionTarget protocol."""
-
-    def __init__(self, boxes: ArrayLike, labels: ArrayLike, scores: ArrayLike) -> None:
-        self._boxes = np.asarray(boxes)
-        self._labels = np.asarray(labels)
-        self._scores = np.asarray(scores)
-
-    @property
-    def boxes(self) -> ArrayLike:
-        return self._boxes
-
-    @property
-    def labels(self) -> ArrayLike:
-        return self._labels
-
-    @property
-    def scores(self) -> ArrayLike:
-        return self._scores
+_TDataset = TypeVar("_TDataset", ic.Dataset, od.Dataset)
 
 
-class BaseDatasetReader(ABC):
+class BaseDatasetReader(Generic[_TDataset], ABC):
     """
     Abstract base class for object detection dataset readers.
 
@@ -65,7 +45,7 @@ class BaseDatasetReader(ABC):
         pass
 
     @abstractmethod
-    def _create_dataset_implementation(self) -> ObjectDetectionDataset:
+    def create_dataset(self) -> _TDataset:
         """Create the format-specific dataset implementation."""
         pass
 
@@ -123,13 +103,59 @@ class BaseDatasetReader(ABC):
 
         return {"is_valid": len(issues) == 0, "issues": issues, "stats": stats}
 
-    def get_dataset(self) -> ObjectDetectionDataset:
-        """
-        Get dataset conforming to MAITE ObjectDetectionDataset protocol.
 
-        Returns
-        -------
-        ObjectDetectionDataset
-            Dataset instance with MAITE-compatible interface
-        """
-        return self._create_dataset_implementation()
+def create_dataset_reader(
+    dataset_path: str | Path, format_hint: str | None = None
+) -> BaseDatasetReader[ic.Dataset] | BaseDatasetReader[od.Dataset]:
+    """
+    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
+    """
+    from maite_datasets.object_detection._coco import COCODatasetReader
+    from maite_datasets.object_detection._yolo import YOLODatasetReader
+
+    dataset_path = Path(dataset_path)
+
+    if format_hint:
+        format_hint = format_hint.lower()
+        if format_hint == "coco":
+            return COCODatasetReader(dataset_path)
+        if format_hint == "yolo":
+            return YOLODatasetReader(dataset_path)
+        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)
+    if has_labels_dir and not has_annotations_json:
+        _logger.info(f"Detected YOLO format for {dataset_path}")
+        return YOLODatasetReader(dataset_path)
+    if 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."
+        )
+    raise ValueError(
+        f"Cannot detect dataset format in {dataset_path}. "
+        "Expected either annotations.json (COCO) or labels/ directory (YOLO)."
+    )

maite_datasets/_validate.py

@@ -2,11 +2,13 @@ from __future__ import annotations
 
 __all__ = []
 
-import numpy as np
 from collections.abc import Sequence, Sized
 from typing import Any, Literal
 
-from maite_datasets._protocols import Array, ObjectDetectionTarget
+import numpy as np
+from maite.protocols.object_detection import ObjectDetectionTarget
+
+from maite_datasets.protocols import Array
 
 
 class ValidationMessages: