datamint 2.44.0__tar.gz → 2.45.0__tar.gz

{datamint-2.44.0 → datamint-2.45.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datamint
-Version: 2.44.0
+Version: 2.45.0
 Summary: A library for interacting with the Datamint API, designed for efficient data management, processing and Deep Learning workflows.
 Keywords: medical-imaging,dicom,nifti,pytorch,mlflow,lightning,datasets,annotation
 Author: SonanceAI
@@ -84,7 +84,7 @@ Description-Content-Type: text/markdown
 ![Build Status](https://github.com/SonanceAI/datamint-python-api/actions/workflows/run_test.yaml/badge.svg)
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
 
-Datamint turns medical imaging ML work. Dataset management, annotation, training, and deployment into a few lines of Python, with built-in support for DICOM/NIfTI/PNG, PyTorch Lightning trainers, and MLflow tracking.
+Datamint turns medical imaging ML work (dataset management, annotation, training and deployment) into a few lines of Python, with built-in support for DICOM, NIfTI and PNG, PyTorch Lightning trainers and MLflow tracking.
 
 **Common use cases:** 🩻 Segmentation · 🏷️ Classification · 📦 Detection
 

{datamint-2.44.0 → datamint-2.45.0}/README.md

@@ -7,7 +7,7 @@
 ![Build Status](https://github.com/SonanceAI/datamint-python-api/actions/workflows/run_test.yaml/badge.svg)
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
 
-Datamint turns medical imaging ML work. Dataset management, annotation, training, and deployment into a few lines of Python, with built-in support for DICOM/NIfTI/PNG, PyTorch Lightning trainers, and MLflow tracking.
+Datamint turns medical imaging ML work (dataset management, annotation, training and deployment) into a few lines of Python, with built-in support for DICOM, NIfTI and PNG, PyTorch Lightning trainers and MLflow tracking.
 
 **Common use cases:** 🩻 Segmentation · 🏷️ Classification · 📦 Detection
 

{datamint-2.44.0 → datamint-2.45.0}/datamint/api/endpoints/annotations_api.py

@@ -6,7 +6,7 @@ from collections.abc import Generator, Sequence
 from datetime import date
 from io import BytesIO
 from pathlib import Path
-from typing import IO, TYPE_CHECKING, Any, BinaryIO, Literal, overload
+from typing import IO, TYPE_CHECKING, Any, Literal, overload
 
 import aiohttp
 import httpx
@@ -36,6 +36,7 @@ from datamint.entities.annotations import (
     annotation_from_dict,
 )
 from datamint.exceptions import ItemNotFoundError, ServerError
+from datamint.utils.date_utils import to_iso_date_str
 from datamint.utils.nifti_utils import metadata_to_nifti_obj
 
 from ..entity_base_api import ApiConfig, CreatableEntityApi, DeletableEntityApi
@@ -81,8 +82,8 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
                  resource: str | Resource | Sequence[str | Resource] | None = None,
                  annotation_type: AnnotationType | str | None = None,
                  annotator_email: str | None = None,
-                 from_date: date | None = None,
-                 to_date: date | None = None,
+                 from_date: date | str | None = None,
+                 to_date: date | str | None = None,
                  dataset_id: str | None = None,
                  worklist_id: str | None = None,
                  status: Literal['new', 'published'] | None = None,
@@ -98,8 +99,8 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
                  resource: str | Resource | Sequence[str | Resource] | None = None,
                  annotation_type: AnnotationType | str | None = None,
                  annotator_email: str | None = None,
-                 from_date: date | None = None,
-                 to_date: date | None = None,
+                 from_date: date | str | None = None,
+                 to_date: date | str | None = None,
                  dataset_id: str | None = None,
                  worklist_id: str | None = None,
                  status: Literal['new', 'published'] | None = None,
@@ -116,8 +117,8 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
         resource: str | Resource | Sequence[str | Resource] | None = None,
         annotation_type: AnnotationType | str | None = None,
         annotator_email: str | None = None,
-        from_date: date | None = None,
-        to_date: date | None = None,
+        from_date: date | str | None = None,
+        to_date: date | str | None = None,
         dataset_id: str | None = None,
         worklist_id: str | None = None,
         status: Literal['new', 'published'] | None = None,
@@ -136,8 +137,8 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
                 a list of resources, or None to retrieve annotations from all resources.
             annotation_type: Filter by annotation type (e.g., 'segmentation', 'category').
             annotator_email: Filter by annotator email address.
-            from_date: Filter annotations created on or after this date.
-            to_date: Filter annotations created on or before this date.
+            from_date: Filter annotations created on or after this date (``date`` or ISO date string).
+            to_date: Filter annotations created on or before this date (``date`` or ISO date string).
             dataset_id: Filter by dataset unique id.
             worklist_id: Filter by annotation worklist unique id.
             status: Filter by annotation status ('new' or 'published').
@@ -190,8 +191,8 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
         payload = {
             'annotation_type': annotation_type,
             'annotatorEmail': annotator_email,
-            'from': from_date.isoformat() if from_date is not None else None,
-            'to': to_date.isoformat() if to_date is not None else None,
+            'from': to_iso_date_str(from_date),
+            'to': to_iso_date_str(to_date),
             'dataset_id': dataset_id,
             'annotation_worklist_id': worklist_id,
             'status': status,
@@ -307,7 +308,7 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
             )
 
         # Handle frame-by-frame upload (existing logic)
-        nframes, fios = AnnotationsApi._generate_segmentations_ios(
+        nframes, frames = AnnotationsApi._generate_segmentation_frames(
             file_path, transpose_segmentation=transpose_segmentation
         )
         if frame_index is None:
@@ -322,11 +323,11 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
             raise ValueError("frame_index must be a list of integers or None.")
 
         annotids = []
-        for fidx, f in zip(frames_indices, fios):
+        for fidx, frame in zip(frames_indices, frames):
             frame_annotids = await self._upload_single_frame_segmentation_async(
                 resource_id=resource_id,
                 frame_index=fidx,
-                fio=f,
+                frame=frame,
                 name=name,
                 imported_from=imported_from,
                 author_email=author_email,
@@ -342,7 +343,7 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
     async def _upload_single_frame_segmentation_async(self,
                                                       resource_id: str,
                                                       frame_index: int | None,
-                                                      fio: IO,
+                                                      frame: np.ndarray,
                                                       name: dict[int, str] | dict[tuple, str],
                                                       imported_from: str | None = None,
                                                       author_email: str | None = None,
@@ -358,7 +359,7 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
         Args:
             resource_id: The resource unique id.
             frame_index: The frame index for the segmentation.
-            fio: File-like object containing the segmentation image.
+            frame: Segmentation frame as a uint8 array of shape (height, width, 3).
             name: The name of the segmentation, a dictionary mapping pixel values to names,
                   or a dictionary mapping RGB tuples to names.
             imported_from: The imported from value.
@@ -372,81 +373,73 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
             List of annotation IDs created.
         """
         try:
-            try:
-                img_pil = Image.open(fio)
-                img_array = np.array(img_pil)  # shape: (height, width, channels)
-                # Returns a list of (count, color) tuples
-                unique_vals = img_pil.getcolors(maxcolors=MAX_NUMBER_DISTINCT_COLORS)
-                # convert to list of RGB tuples
-                if unique_vals is None:
-                    raise ValueError(f'Number of unique colors exceeds {MAX_NUMBER_DISTINCT_COLORS}.')
-                rgb_unique_vals = [
-                    (int(color[0]), int(color[1]), int(color[2]))
-                    for _, color in unique_vals
-                    if isinstance(color, tuple) and len(color) >= 3
-                ]
-                # Remove black/transparent pixels
-                black_pixel = (0, 0, 0)
-                rgb_unique_vals = [rgb for rgb in rgb_unique_vals if rgb != black_pixel]
-
-                rgb_name_map: dict[tuple[int, int, int] | str, str] = {}
-                for key, value in name.items():
-                    if key == 'default':
-                        rgb_name_map['default'] = value
-                    elif isinstance(key, tuple) and len(key) >= 3:
-                        rgb_name_map[(int(key[0]), int(key[1]), int(key[2]))] = value
-
-                if discard_empty_segmentations:
-                    if len(rgb_unique_vals) == 0:
-                        msg = f"Discarding empty RGB segmentation for frame {frame_index}"
-                        _LOGGER.debug(msg)
-                        _USER_LOGGER.debug(msg)
-                        return []
-                segnames = AnnotationsApi._get_segmentation_names_rgb(rgb_unique_vals, names=rgb_name_map)
-                segs_generator = AnnotationsApi._split_rgb_segmentations(img_array, rgb_unique_vals)
-
-                fio.seek(0)
-                # TODO: Optimize this. It is not necessary to open the image twice.
-
-                # Create annotations
-                annotations: list[CreateAnnotationDto] = []
-                for segname in segnames:
-                    ann = CreateAnnotationDto(
-                        type='segmentation',
-                        identifier=segname,
-                        scope='frame',
-                        frame_index=frame_index,
-                        imported_from=imported_from,
-                        import_author=author_email,
-                        model_id=model_id,
-                        annotation_worklist_id=worklist_id,
-                        source=source,
-                    )
-                    annotations.append(ann)
-
-                # Validate unique identifiers
-                if len(annotations) != len({a.identifier for a in annotations}):
-                    raise ValueError(
-                        "Multiple annotations with the same identifier, frame_index, scope and author is not supported yet."
-                    )
-
-                annotids = await self._create_annotations_async(resource_id=resource_id,
-                                                                annotations_dto=annotations,
-                                                                session=session)
+            # Returns a list of (count, color) tuples
+            unique_vals = Image.fromarray(frame).getcolors(maxcolors=MAX_NUMBER_DISTINCT_COLORS)
+            # convert to list of RGB tuples
+            if unique_vals is None:
+                raise ValueError(f'Number of unique colors exceeds {MAX_NUMBER_DISTINCT_COLORS}.')
+            rgb_unique_vals = [
+                (int(color[0]), int(color[1]), int(color[2]))
+                for _, color in unique_vals
+                if isinstance(color, tuple) and len(color) >= 3
+            ]
+            # Remove black pixels
+            black_pixel = (0, 0, 0)
+            rgb_unique_vals = [rgb for rgb in rgb_unique_vals if rgb != black_pixel]
+
+            rgb_name_map: dict[tuple[int, int, int] | str, str] = {}
+            for key, value in name.items():
+                if key == 'default':
+                    rgb_name_map['default'] = value
+                elif isinstance(key, tuple) and len(key) >= 3:
+                    rgb_name_map[(int(key[0]), int(key[1]), int(key[2]))] = value
+
+            if discard_empty_segmentations:
+                if len(rgb_unique_vals) == 0:
+                    msg = f"Discarding empty RGB segmentation for frame {frame_index}"
+                    _LOGGER.debug(msg)
+                    _USER_LOGGER.debug(msg)
+                    return []
+            segnames = AnnotationsApi._get_segmentation_names_rgb(rgb_unique_vals, names=rgb_name_map)
+            segs_generator = AnnotationsApi._split_rgb_segmentations(frame, rgb_unique_vals)
+
+            # Create annotations
+            annotations: list[CreateAnnotationDto] = []
+            for segname in segnames:
+                ann = CreateAnnotationDto(
+                    type='segmentation',
+                    identifier=segname,
+                    scope='frame',
+                    frame_index=frame_index,
+                    imported_from=imported_from,
+                    import_author=author_email,
+                    model_id=model_id,
+                    annotation_worklist_id=worklist_id,
+                    source=source,
+                )
+                annotations.append(ann)
 
-                # Upload segmentation files
-                if len(annotids) != len(segnames):
-                    _LOGGER.warning(f"Number of uploaded annotations ({len(annotids)})" +
-                                    f" does not match the number of annotations ({len(segnames)})")
+            # Validate unique identifiers
+            if len(annotations) != len({a.identifier for a in annotations}):
+                raise ValueError(
+                    "Multiple annotations with the same identifier, frame_index, scope and author is not supported yet."
+                )
 
-                for annotid, segname, fio_seg in zip(annotids, segnames, segs_generator):
-                    await self.upload_annotation_file_async(resource_id, annotid, fio_seg,
-                                                            content_type='image/png',
-                                                            filename=segname,
+            annotids = await self._create_annotations_async(resource_id=resource_id,
+                                                            annotations_dto=annotations,
                                                             session=session)
-                return annotids
-            finally:
-                fio.close()
+
+            # Upload segmentation files
+            if len(annotids) != len(segnames):
+                _LOGGER.warning(f"Number of uploaded annotations ({len(annotids)})" +
+                                f" does not match the number of annotations ({len(segnames)})")
+
+            for annotid, segname, fio_seg in zip(annotids, segnames, segs_generator):
+                await self.upload_annotation_file_async(resource_id, annotid, fio_seg,
+                                                        content_type='image/png',
+                                                        filename=segname,
+                                                        session=session)
+            return annotids
         except ItemNotFoundError:
             raise ItemNotFoundError('resource', {'resource_id': resource_id})
 
@@ -1013,9 +1006,9 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
         _USER_LOGGER.info(f'Volume segmentation uploaded for resource {resource_id}')
 
     @staticmethod
-    def _generate_segmentations_ios(file_path: str | np.ndarray,
-                                    transpose_segmentation: bool = False
-                                    ) -> tuple[int, Generator[BinaryIO, None, None]]:
+    def _generate_segmentation_frames(file_path: str | np.ndarray,
+                                      transpose_segmentation: bool = False
+                                      ) -> tuple[int, Generator[np.ndarray, None, None]]:
         if not isinstance(file_path, (str, np.ndarray)):
             raise ValueError(f"Unsupported file type: {type(file_path)}")
 
@@ -1029,7 +1022,7 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
                 normalized_imgs = normalized_imgs.transpose(0, 2, 1, 3)
 
             nframes = normalized_imgs.shape[3]
-            fios = AnnotationsApi._numpy_to_bytesio_png(normalized_imgs)
+            frames = AnnotationsApi._numpy_to_rgb_frames(normalized_imgs)
 
         elif file_path.endswith(('.nii', '.nii.gz')):
             loaded_image: Any = nib_load(file_path)
@@ -1045,7 +1038,7 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
                 normalized_imgs = normalized_imgs.transpose(0, 2, 1, 3)
 
             nframes = normalized_imgs.shape[3]
-            fios = AnnotationsApi._numpy_to_bytesio_png(normalized_imgs)
+            frames = AnnotationsApi._numpy_to_rgb_frames(normalized_imgs)
 
         elif file_path.endswith('.png'):
             with Image.open(file_path) as img:
@@ -1055,12 +1048,12 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
                 if transpose_segmentation:
                     normalized_imgs = normalized_imgs.transpose(0, 2, 1, 3)
 
-                fios = AnnotationsApi._numpy_to_bytesio_png(normalized_imgs)
+                frames = AnnotationsApi._numpy_to_rgb_frames(normalized_imgs)
                 nframes = 1
         else:
             raise ValueError(f"Unsupported file format of '{file_path}'")
 
-        return nframes, fios
+        return nframes, frames
 
     @staticmethod
     def _normalize_segmentation_array(seg_imgs: np.ndarray) -> np.ndarray:
@@ -1087,15 +1080,15 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
         return seg_imgs
 
     @staticmethod
-    def _numpy_to_bytesio_png(seg_imgs: np.ndarray) -> Generator[BinaryIO, None, None]:
+    def _numpy_to_rgb_frames(seg_imgs: np.ndarray) -> Generator[np.ndarray, None, None]:
         """
-        Convert normalized segmentation images to PNG BytesIO objects.
+        Convert normalized segmentation images to RGB frames.
 
         Args:
             seg_imgs: Normalized segmentation array in shape (channels, height, width, frames).
 
         Yields:
-            BinaryIO: PNG image data as BytesIO objects
+            np.ndarray: uint8 array of shape (height, width, 3)
         """
         # PIL RGB format is: (height, width, channels)
         if seg_imgs.shape[0] not in [1, 3, 4]:
@@ -1104,13 +1097,8 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
         for i in range(nframes):
             img = seg_imgs[:, :, :, i].astype(np.uint8)
             if img.shape[0] == 1:
-                pil_img = Image.fromarray(img[0]).convert('RGB')
-            else:
-                pil_img = Image.fromarray(img.transpose(1, 2, 0))
-            img_bytes = BytesIO()
-            pil_img.save(img_bytes, format='PNG')
-            img_bytes.seek(0)
-            yield img_bytes
+                img = np.repeat(img, 3, axis=0)
+            yield np.ascontiguousarray(img[:3].transpose(1, 2, 0))
 
     def create_image_classification(self,
                                     resource: str | Resource,

{datamint-2.44.0 → datamint-2.45.0}/datamint/api/endpoints/annotationsets_api.py

@@ -1,10 +1,12 @@
 import logging
 from collections.abc import Sequence
+from datetime import date
 from typing import TYPE_CHECKING, Any, Literal, overload
 
 from typing_extensions import override
 
 from datamint.entities.annotation_worklist import AnnotationWorklist
+from datamint.utils.date_utils import to_iso_date_str
 
 from ..entity_base_api import CreatableEntityApi, UpdatableEntityApi
 
@@ -723,8 +725,8 @@ class AnnotationWorklistApi(CreatableEntityApi[AnnotationWorklist],
     def download_annotations(
         self,
         worklist_id: str | None = None,
-        from_date: str | None = None,
-        to_date: str | None = None,
+        from_date: date | str | None = None,
+        to_date: date | str | None = None,
         annotators: list[str] | None = None,
         annotations: list[str] | None = None,
         format: str = 'csv',
@@ -733,8 +735,8 @@ class AnnotationWorklistApi(CreatableEntityApi[AnnotationWorklist],
 
         Args:
             worklist_id: The annotation worklist ID.
-            from_date: Optional start date filter (ISO string).
-            to_date: Optional end date filter (ISO string).
+            from_date: Optional start date filter (``date`` or ISO date string).
+            to_date: Optional end date filter (``date`` or ISO date string).
             annotators: Optional list of annotator emails. Accepts either a repeated/array
                 input or a comma-separated string.
             annotations: Optional list of annotation identifiers. Accepts either a repeated/array
@@ -749,9 +751,9 @@ class AnnotationWorklistApi(CreatableEntityApi[AnnotationWorklist],
 
         params: dict[str, str | list[str]] = {'format': format}
         if from_date is not None:
-            params['from'] = from_date
+            params['from'] = to_iso_date_str(from_date)
         if to_date is not None:
-            params['to'] = to_date
+            params['to'] = to_iso_date_str(to_date)
         if annotators is not None:
             params['annotators[]'] = annotators
         if annotations is not None:

{datamint-2.44.0 → datamint-2.45.0}/datamint/api/endpoints/projects_api.py

@@ -1,5 +1,6 @@
 import uuid
 from collections.abc import Sequence
+from datetime import date
 from pathlib import Path
 from typing import TYPE_CHECKING, Literal, overload
 
@@ -8,6 +9,7 @@ import httpx
 from datamint.entities.project import Project
 from datamint.entities.project_resource_split import ProjectResourceSplit
 from datamint.entities.resource import Resource
+from datamint.utils.date_utils import to_iso_date_str
 from datamint.exceptions import (
     DefaultProjectNotSetError,
     EntityAlreadyExistsError,
@@ -544,8 +546,8 @@ class ProjectsApi(CRUDEntityApi[Project]):
                              format: str = 'csv',
                              annotators: list[str] | None = None,
                              annotations: list[str] | None = None,
-                             from_date: str | None = None,
-                             to_date: str | None = None,
+                             from_date: date | str | None = None,
+                             to_date: date | str | None = None,
                              progress_bar: bool = True,
                              project: str | Project | None = None) -> None:
         """Download annotation data as a CSV or Excel file.
@@ -555,8 +557,8 @@ class ProjectsApi(CRUDEntityApi[Project]):
             format: Export format, ``'csv'`` (default) or ``'xlsx'``.
             annotators: Optional list of annotator emails to include.
             annotations: Optional list of annotation identifiers to include.
-            from_date: Optional start date filter (ISO string).
-            to_date: Optional end date filter (ISO string).
+            from_date: Optional start date filter (``date`` or ISO date string).
+            to_date: Optional end date filter (``date`` or ISO date string).
             progress_bar: Whether to display a progress bar.
             project: The project ID or Project instance. Falls back to the
                 session's default project (see `datamint.select_project()`) when omitted.
@@ -566,9 +568,9 @@ class ProjectsApi(CRUDEntityApi[Project]):
         proj_id = self._entid(self._resolve_project_or_default(project))
         params: dict = {'format': format}
         if from_date is not None:
-            params['from'] = from_date
+            params['from'] = to_iso_date_str(from_date)
         if to_date is not None:
-            params['to'] = to_date
+            params['to'] = to_iso_date_str(to_date)
         if annotators is not None:
             params['annotators[]'] = annotators
         if annotations is not None:

{datamint-2.44.0 → datamint-2.45.0}/datamint/api/endpoints/resources_api.py

@@ -30,6 +30,7 @@ from datamint.entities.annotations import AnnotationType
 from datamint.entities.annotations.annotation import Annotation
 from datamint.exceptions import ItemNotFoundError, ServerError, ValidationError
 from datamint.types import ImagingData
+from datamint.utils.date_utils import to_iso_date_str
 from datamint.utils.collection_utils import ChainedSequence
 
 from ..base_api import ApiConfig, BaseApi
@@ -191,22 +192,10 @@ class ResourcesApi(CreatableEntityApi[Resource], DeletableEntityApi[Resource]):
                 'include' returns both. Deleted resources are only visible to admins and librarians.
         """
 
-        # Convert datetime objects to ISO format
-        if from_date:
-            if isinstance(from_date, str):
-                date.fromisoformat(from_date)
-            else:
-                from_date = from_date.isoformat()
-        if to_date:
-            if isinstance(to_date, str):
-                date.fromisoformat(to_date)
-            else:
-                to_date = to_date.isoformat()
-
         # Prepare the payload
         payload = {
-            "from": from_date,
-            "to": to_date,
+            "from": to_iso_date_str(from_date),
+            "to": to_iso_date_str(to_date),
             "status": status if status is not None else "",
             "modality": modality,
             "mimetype": mimetype,

{datamint-2.44.0 → datamint-2.45.0}/datamint/entities/annotations/base_segmentation.py

@@ -20,7 +20,7 @@ from pydantic import BeforeValidator, Field, PlainSerializer
 
 from datamint.types import CacheMode, ImagingData
 
-from .annotation import Annotation
+from .annotation import Annotation, _normalize_annotation_data
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -286,6 +286,63 @@ class BaseSegmentationAnnotation(Annotation):
             'Use upload_segmentations or upload_volume_segmentation instead.'
         )
 
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'BaseSegmentationAnnotation':
+        """Create a segmentation annotation from a dictionary.
+
+        This overrides :meth:`Annotation.from_dict`, which rejects
+        segmentation annotations that have no associated ``file``.  A
+        segmentation payload may instead carry the mask inline through the
+        ``segmentation_data`` field (or its ``mask`` alias), as produced by
+        :meth:`BaseEntity.asdict` / ``model_dump``.  Such payloads are
+        accepted here and the mask is decoded by the Pydantic
+        ``BeforeValidator`` on :attr:`segmentation_data`.
+
+        Args:
+            data: Dictionary containing annotation data, optionally including
+                an inline ``segmentation_data`` (or ``mask``) payload.
+
+        Returns:
+            A segmentation annotation instance with ``segmentation_data``
+            decoded to a native object (``np.ndarray``, ``PIL.Image.Image``
+            or ``Nifti1Image``).
+
+        Raises:
+            ValueError: If neither an associated ``file`` nor an inline
+                ``segmentation_data`` payload is present.
+
+        Example:
+            >>> import json
+            >>> from datamint.entities.annotations import ImageSegmentation
+            >>> with open('annotation.json') as f:
+            ...     raw = json.load(f)  # list[list[dict]]
+            >>> seg = ImageSegmentation.from_dict(raw[0][0])
+            >>> seg.segmentation_data.shape
+        """
+        converted_data = _normalize_annotation_data(data)
+
+        has_inline_mask = (
+            converted_data.get('segmentation_data') is not None
+            or converted_data.get('mask') is not None
+        )
+
+        if converted_data.get('file') is None and not has_inline_mask:
+            raise ValueError(
+                "Segmentation annotations must have an associated file or an "
+                f"inline segmentation_data payload. {data}"
+            )
+
+        # Accept both field names and their aliases (e.g. ``mask`` for
+        # ``segmentation_data``) so inline payloads are not silently dropped.
+        valid_fields = set(cls.model_fields)
+        for field in cls.model_fields.values():
+            if field.alias:
+                valid_fields.add(field.alias)
+
+        filtered_data = {k: v for k, v in converted_data.items() if k in valid_fields}
+
+        return cls(**filtered_data)
+
     @overload
     def fetch_file_data(
         self,

{datamint-2.44.0 → datamint-2.45.0}/datamint/mlflow/flavors/model.py

@@ -281,28 +281,35 @@ class BaseDatamintModel(PythonModel, ABC):
         :class:`~datamint.mlflow.flavors.prediction_router.DeployedModelPrompts` instance before dispatch,
         so ``predict_*`` handlers receive a typed object rather than a raw dict. 
         """
-        params = dict(params or {})
-        log_predictions = params.pop('log_predictions', False)
-        model_name = params.pop('model_name', None)
-
-        raw_prompts = params.pop('prompts', None)
-        if raw_prompts is not None:
-            
-            # Sent JSON-encoded
-            if isinstance(raw_prompts, str):
-                raw_prompts = json.loads(raw_prompts)
-            params['prompts'] = (
-                raw_prompts
-                if isinstance(raw_prompts, DeployedModelPrompts)
-                else DeployedModelPrompts.from_dict(raw_prompts)
-            )
+        logger.info(f'Predicting on {len(model_input)} resources')
+        try:
+            params = dict(params or {})
+            log_predictions = params.pop('log_predictions', False)
+            model_name = params.pop('model_name', None)
+
+            raw_prompts = params.pop('prompts', None)
+            if raw_prompts is not None:
+                
+                # Sent JSON-encoded
+                if isinstance(raw_prompts, str):
+                    raw_prompts = json.loads(raw_prompts)
+                params['prompts'] = (
+                    raw_prompts
+                    if isinstance(raw_prompts, DeployedModelPrompts)
+                    else DeployedModelPrompts.from_dict(raw_prompts)
+                )
+
 
-        result = self._router.dispatch(model_input, params)
+            result = self._router.dispatch(model_input, params)
 
-        if log_predictions:
-            self._log_predictions(model_input, result, model_name=model_name)
+            if log_predictions:
+                self._log_predictions(model_input, result, model_name=model_name)
 
-        return result
+            return result
+        except Exception as e:
+            logger.error(f'Failed to predict on {len(model_input)} resources: {e}')
+            logger.exception(e)
+            raise
 
     def _log_predictions(
         self,

datamint-2.45.0/datamint/utils/date_utils.py

@@ -0,0 +1,21 @@
+from datetime import date
+
+
+def to_iso_date_str(value: date | str | None) -> str | None:
+    """Normalize a date filter to an ISO 8601 string.
+
+    Args:
+        value: A ``date``/``datetime`` or an ISO date string (``YYYY-MM-DD``).
+
+    Returns:
+        The ISO string, or ``None`` if ``value`` is ``None``.
+
+    Raises:
+        ValueError: If ``value`` is a string that is not a valid ISO date.
+    """
+    if value is None:
+        return None
+    if isinstance(value, str):
+        date.fromisoformat(value)
+        return value
+    return value.isoformat()