maite-datasets 0.0.4__tar.gz → 0.0.5__tar.gz

{maite_datasets-0.0.4 → maite_datasets-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maite-datasets
-Version: 0.0.4
+Version: 0.0.5
 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

{maite_datasets-0.0.4 → maite_datasets-0.0.5}/src/maite_datasets/_builder.py

@@ -22,11 +22,12 @@ from maite_datasets._protocols import (
     DatasetMetadata,
     ImageClassificationDataset,
     ObjectDetectionDataset,
+    DatumMetadata,
 )
 
 
-def _ensure_id(index: int, metadata: dict[str, Any]) -> dict[str, Any]:
-    return {"id": index, **metadata} if "id" not in metadata else metadata
+def _ensure_id(index: int, metadata: dict[str, Any]) -> DatumMetadata:
+    return DatumMetadata(**({"id": index, **metadata} if "id" not in metadata else metadata))
 
 
 def _validate_data(
@@ -141,7 +142,7 @@ class CustomImageClassificationDataset(BaseAnnotatedDataset[Sequence[int]], Imag
             self.__class__.__name__ = name
             self.__class__.__qualname__ = name
 
-    def __getitem__(self, idx: int, /) -> tuple[Array, Array, dict[str, Any]]:
+    def __getitem__(self, idx: int, /) -> tuple[Array, Array, DatumMetadata]:
         one_hot = [0.0] * len(self._index2label)
         one_hot[self._labels[idx]] = 1.0
         return (
@@ -206,7 +207,7 @@ class CustomObjectDetectionDataset(BaseAnnotatedDataset[Sequence[Sequence[int]]]
     def metadata(self) -> DatasetMetadata:
         return DatasetMetadata(id=self._id, index2label=self._index2label)
 
-    def __getitem__(self, idx: int, /) -> tuple[Array, ObjectDetectionTarget, dict[str, Any]]:
+    def __getitem__(self, idx: int, /) -> tuple[Array, ObjectDetectionTarget, DatumMetadata]:
         return (
             self._images[idx],
             self.ObjectDetectionTarget(self._labels[idx], self._bboxes[idx], len(self._classes)),

{maite_datasets-0.0.4 → maite_datasets-0.0.5}/src/maite_datasets/_reader/_base.py

@@ -49,8 +49,8 @@ class BaseDatasetReader(ABC):
     """
 
     def __init__(self, dataset_path: str | Path, dataset_id: str | None = None) -> None:
-        self.dataset_path = Path(dataset_path)
-        self._dataset_id = dataset_id or self.dataset_path.name
+        self.dataset_path: Path = Path(dataset_path)
+        self.dataset_id: str = dataset_id or self.dataset_path.name
 
         # Basic path validation
         if not self.dataset_path.exists():

{maite_datasets-0.0.4 → maite_datasets-0.0.5}/src/maite_datasets/_reader/_coco.py

@@ -107,23 +107,23 @@ class COCODatasetReader(BaseDatasetReader):
         classes_file: str | None = "classes.txt",
         dataset_id: str | None = None,
     ) -> None:
-        self.annotation_file = annotation_file
-        self.images_dir = images_dir
-        self.classes_file = classes_file
+        self._annotation_file = annotation_file
+        self._images_dir = images_dir
+        self._classes_file = classes_file
 
         # Initialize base class
         super().__init__(dataset_path, dataset_id)
 
     def _initialize_format_specific(self) -> None:
         """Initialize COCO-specific components."""
-        self.images_path = self.dataset_path / self.images_dir
-        self.annotation_path = self.dataset_path / self.annotation_file
-        self.classes_path = self.dataset_path / self.classes_file if self.classes_file else None
+        self._images_path = self.dataset_path / self._images_dir
+        self._annotation_path = self.dataset_path / self._annotation_file
+        self._classes_path = self.dataset_path / self._classes_file if self._classes_file else None
 
-        if not self.annotation_path.exists():
-            raise FileNotFoundError(f"Annotation file not found: {self.annotation_path}")
-        if not self.images_path.exists():
-            raise FileNotFoundError(f"Images directory not found: {self.images_path}")
+        if not self._annotation_path.exists():
+            raise FileNotFoundError(f"Annotation file not found: {self._annotation_path}")
+        if not self._images_path.exists():
+            raise FileNotFoundError(f"Images directory not found: {self._images_path}")
 
         self._load_annotations()
 
@@ -141,62 +141,62 @@ class COCODatasetReader(BaseDatasetReader):
         issues = []
         stats = {}
 
-        annotation_path = self.dataset_path / self.annotation_file
+        annotation_path = self.dataset_path / self._annotation_file
         if not annotation_path.exists():
-            issues.append(f"Missing {self.annotation_file} file")
+            issues.append(f"Missing {self._annotation_file} file")
             return issues, stats
 
         try:
             with open(annotation_path) as f:
                 coco_data = json.load(f)
         except json.JSONDecodeError as e:
-            issues.append(f"Invalid JSON in {self.annotation_file}: {e}")
+            issues.append(f"Invalid JSON in {self._annotation_file}: {e}")
             return issues, stats
 
         # Check required keys
         required_keys = ["images", "annotations", "categories"]
         for key in required_keys:
             if key not in coco_data:
-                issues.append(f"Missing required key '{key}' in {self.annotation_file}")
+                issues.append(f"Missing required key '{key}' in {self._annotation_file}")
             else:
                 stats[f"num_{key}"] = len(coco_data[key])
 
         # Check optional classes.txt
-        if self.classes_file:
-            classes_path = self.dataset_path / self.classes_file
+        if self._classes_file:
+            classes_path = self.dataset_path / self._classes_file
             if classes_path.exists():
                 try:
                     with open(classes_path) as f:
                         class_lines = [line.strip() for line in f if line.strip()]
                     stats["num_class_names"] = len(class_lines)
                 except Exception as e:
-                    issues.append(f"Error reading {self.classes_file}: {e}")
+                    issues.append(f"Error reading {self._classes_file}: {e}")
 
         return issues, stats
 
     def _load_annotations(self) -> None:
         """Load and parse COCO annotations."""
-        with open(self.annotation_path) as f:
-            self.coco_data = json.load(f)
+        with open(self._annotation_path) as f:
+            self._coco_data = json.load(f)
 
         # Build mappings
-        self.image_id_to_info = {img["id"]: img for img in self.coco_data["images"]}
-        self.category_id_to_idx = {cat["id"]: idx for idx, cat in enumerate(self.coco_data["categories"])}
+        self._image_id_to_info = {img["id"]: img for img in self._coco_data["images"]}
+        self._category_id_to_idx = {cat["id"]: idx for idx, cat in enumerate(self._coco_data["categories"])}
 
         # Group annotations by image
         self.image_id_to_annotations: dict[int, list[dict[str, Any]]] = {}
-        for ann in self.coco_data["annotations"]:
+        for ann in self._coco_data["annotations"]:
             img_id = ann["image_id"]
             if img_id not in self.image_id_to_annotations:
                 self.image_id_to_annotations[img_id] = []
             self.image_id_to_annotations[img_id].append(ann)
 
         # Load class names
-        if self.classes_path and self.classes_path.exists():
-            with open(self.classes_path) as f:
+        if self._classes_path and self._classes_path.exists():
+            with open(self._classes_path) as f:
                 class_names = [line.strip() for line in f if line.strip()]
         else:
-            class_names = [cat["name"] for cat in self.coco_data["categories"]]
+            class_names = [cat["name"] for cat in self._coco_data["categories"]]
 
         self._index2label = {idx: name for idx, name in enumerate(class_names)}
 
@@ -206,12 +206,12 @@ class _COCODataset:
 
     def __init__(self, reader: COCODatasetReader) -> None:
         self.reader = reader
-        self.image_ids = list(reader.image_id_to_info.keys())
+        self.image_ids = list(reader._image_id_to_info.keys())
 
     @property
     def metadata(self) -> DatasetMetadata:
         return DatasetMetadata(
-            id=self.reader._dataset_id,
+            id=self.reader.dataset_id,
             index2label=self.reader.index2label,
         )
 
@@ -220,10 +220,10 @@ class _COCODataset:
 
     def __getitem__(self, index: int) -> ObjectDetectionDatum:
         image_id = self.image_ids[index]
-        image_info = self.reader.image_id_to_info[image_id]
+        image_info = self.reader._image_id_to_info[image_id]
 
         # Load image
-        image_path = self.reader.images_path / image_info["file_name"]
+        image_path = self.reader._images_path / image_info["file_name"]
         image = np.array(Image.open(image_path).convert("RGB"))
         image = np.transpose(image, (2, 0, 1))  # Convert to CHW format
 
@@ -241,7 +241,7 @@ class _COCODataset:
                 boxes.append([x, y, x + w, y + h])
 
                 # Map category_id to class index
-                cat_idx = self.reader.category_id_to_idx[ann["category_id"]]
+                cat_idx = self.reader._category_id_to_idx[ann["category_id"]]
                 labels.append(cat_idx)
 
                 # Collect annotation metadata
@@ -271,17 +271,21 @@ class _COCODataset:
 
         # Create comprehensive datum metadata
         datum_metadata = DatumMetadata(
-            id=f"{self.reader._dataset_id}_{image_id}",
-            # Image-level metadata
-            coco_image_id=image_id,
-            file_name=image_info["file_name"],
-            width=image_info["width"],
-            height=image_info["height"],
-            # Optional COCO image fields
-            **{key: value for key, value in image_info.items() if key not in ["id", "file_name", "width", "height"]},
-            # Annotation metadata
-            annotations=annotation_metadata,
-            num_annotations=len(annotations),
+            **{
+                "id": f"{self.reader.dataset_id}_{image_id}",
+                # Image-level metadata
+                "coco_image_id": image_id,
+                "file_name": image_info["file_name"],
+                "width": image_info["width"],
+                "height": image_info["height"],
+                # Optional COCO image fields
+                **{
+                    key: value for key, value in image_info.items() if key not in ["id", "file_name", "width", "height"]
+                },
+                # Annotation metadata
+                "annotations": annotation_metadata,
+                "num_annotations": len(annotations),
+            }
         )
 
         return image, target, datum_metadata

{maite_datasets-0.0.4 → maite_datasets-0.0.5}/src/maite_datasets/_reader/_yolo.py

@@ -88,29 +88,29 @@ class YOLODatasetReader(BaseDatasetReader):
         dataset_id: str | None = None,
         image_extensions: list[str] | None = None,
     ) -> None:
-        self.images_dir = images_dir
-        self.labels_dir = labels_dir
-        self.classes_file = classes_file
+        self._images_dir = images_dir
+        self._labels_dir = labels_dir
+        self._classes_file = classes_file
 
         if image_extensions is None:
             image_extensions = [".jpg", ".jpeg", ".png", ".bmp"]
-        self.image_extensions = [ext.lower() for ext in image_extensions]
+        self._image_extensions = [ext.lower() for ext in image_extensions]
 
         # Initialize base class
         super().__init__(dataset_path, dataset_id)
 
     def _initialize_format_specific(self) -> None:
         """Initialize YOLO-specific components."""
-        self.images_path = self.dataset_path / self.images_dir
-        self.labels_path = self.dataset_path / self.labels_dir
-        self.classes_path = self.dataset_path / self.classes_file
+        self._images_path = self.dataset_path / self._images_dir
+        self._labels_path = self.dataset_path / self._labels_dir
+        self._classes_path = self.dataset_path / self._classes_file
 
-        if not self.images_path.exists():
-            raise FileNotFoundError(f"Images directory not found: {self.images_path}")
-        if not self.labels_path.exists():
-            raise FileNotFoundError(f"Labels directory not found: {self.labels_path}")
-        if not self.classes_path.exists():
-            raise FileNotFoundError(f"Classes file not found: {self.classes_path}")
+        if not self._images_path.exists():
+            raise FileNotFoundError(f"Images directory not found: {self._images_path}")
+        if not self._labels_path.exists():
+            raise FileNotFoundError(f"Labels directory not found: {self._labels_path}")
+        if not self._classes_path.exists():
+            raise FileNotFoundError(f"Classes file not found: {self._classes_path}")
 
         self._load_class_names()
         self._find_image_files()
@@ -130,32 +130,32 @@ class YOLODatasetReader(BaseDatasetReader):
         stats = {}
 
         # Check labels directory
-        labels_path = self.dataset_path / self.labels_dir
+        labels_path = self.dataset_path / self._labels_dir
         if not labels_path.exists():
-            issues.append(f"Missing {self.labels_dir}/ directory")
+            issues.append(f"Missing {self._labels_dir}/ directory")
         else:
             label_files = list(labels_path.glob("*.txt"))
             stats["num_label_files"] = len(label_files)
             if len(label_files) == 0:
-                issues.append(f"No label files found in {self.labels_dir}/ directory")
+                issues.append(f"No label files found in {self._labels_dir}/ directory")
             else:
                 # Validate label file format (sample check)
                 label_issues = self._validate_yolo_label_format(labels_path)
                 issues.extend(label_issues)
 
         # Check required classes.txt
-        classes_path = self.dataset_path / self.classes_file
+        classes_path = self.dataset_path / self._classes_file
         if not classes_path.exists():
-            issues.append(f"Missing required {self.classes_file} file")
+            issues.append(f"Missing required {self._classes_file} file")
         else:
             try:
                 with open(classes_path) as f:
                     class_lines = [line.strip() for line in f if line.strip()]
                 stats["num_classes"] = len(class_lines)
                 if len(class_lines) == 0:
-                    issues.append(f"{self.classes_file} is empty")
+                    issues.append(f"{self._classes_file} is empty")
             except Exception as e:
-                issues.append(f"Error reading {self.classes_file}: {e}")
+                issues.append(f"Error reading {self._classes_file}: {e}")
 
         return issues, stats
 
@@ -167,6 +167,7 @@ class YOLODatasetReader(BaseDatasetReader):
         if not label_files:
             return issues
 
+        label_files.sort()
         sample_label = label_files[0]
         try:
             with open(sample_label) as f:
@@ -197,19 +198,19 @@ class YOLODatasetReader(BaseDatasetReader):
 
     def _load_class_names(self) -> None:
         """Load class names from classes file."""
-        with open(self.classes_path) as f:
+        with open(self._classes_path) as f:
             class_names = [line.strip() for line in f if line.strip()]
         self._index2label = {idx: name for idx, name in enumerate(class_names)}
 
     def _find_image_files(self) -> None:
         """Find all valid image files."""
-        self.image_files = []
-        for ext in self.image_extensions:
-            self.image_files.extend(self.images_path.glob(f"*{ext}"))
-        self.image_files.sort()
+        self._image_files = []
+        for ext in self._image_extensions:
+            self._image_files.extend(self._images_path.glob(f"*{ext}"))
+        self._image_files.sort()
 
-        if not self.image_files:
-            raise ValueError(f"No image files found in {self.images_path}")
+        if not self._image_files:
+            raise ValueError(f"No image files found in {self._images_path}")
 
 
 class _YOLODataset:
@@ -221,15 +222,15 @@ class _YOLODataset:
     @property
     def metadata(self) -> DatasetMetadata:
         return DatasetMetadata(
-            id=self.reader._dataset_id,
+            id=self.reader.dataset_id,
             index2label=self.reader.index2label,
         )
 
     def __len__(self) -> int:
-        return len(self.reader.image_files)
+        return len(self.reader._image_files)
 
     def __getitem__(self, index: int) -> ObjectDetectionDatum:
-        image_path = self.reader.image_files[index]
+        image_path = self.reader._image_files[index]
 
         # Load image
         image = np.array(Image.open(image_path).convert("RGB"))
@@ -237,7 +238,7 @@ class _YOLODataset:
         image = np.transpose(image, (2, 0, 1))  # Convert to CHW format
 
         # Load corresponding label file
-        label_path = self.reader.labels_path / f"{image_path.stem}.txt"
+        label_path = self.reader._labels_path / f"{image_path.stem}.txt"
 
         annotation_metadata = []
         if label_path.exists():
@@ -295,18 +296,20 @@ class _YOLODataset:
 
         # Create comprehensive datum metadata
         datum_metadata = DatumMetadata(
-            id=f"{self.reader._dataset_id}_{image_path.stem}",
-            # Image-level metadata
-            file_name=image_path.name,
-            file_path=str(image_path),
-            width=img_width,
-            height=img_height,
-            # Label file metadata
-            label_file=label_path.name if label_path.exists() else None,
-            label_file_exists=label_path.exists(),
-            # Annotation metadata
-            annotations=annotation_metadata,
-            num_annotations=len(annotation_metadata),
+            **{
+                "id": f"{self.reader.dataset_id}_{image_path.stem}",
+                # Image-level metadata
+                "file_name": image_path.name,
+                "file_path": str(image_path),
+                "width": img_width,
+                "height": img_height,
+                # Label file metadata
+                "label_file": label_path.name if label_path.exists() else None,
+                "label_file_exists": label_path.exists(),
+                # Annotation metadata
+                "annotations": annotation_metadata,
+                "num_annotations": len(annotation_metadata),
+            }
         )
 
         return image, target, datum_metadata