datamint 2.40.0__tar.gz → 2.41.0__tar.gz

{datamint-2.40.0 → datamint-2.41.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datamint
-Version: 2.40.0
+Version: 2.41.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

{datamint-2.40.0 → datamint-2.41.0}/datamint/api/dto/annotation_dto.py

@@ -39,7 +39,8 @@ class CreateAnnotationDto:
                  model_id: str | None = None,
                  geometry: 'Geometry | None' = None,
                  units: str | None = None,
-                 source: str | None = None):
+                 source: str | None = None,
+                 frame_range: tuple[int, int] | None = None):
         self.type = type if isinstance(type, AnnotationType) else AnnotationType(type)
         self.value = value
         self.identifier = identifier
@@ -48,6 +49,7 @@ class CreateAnnotationDto:
         self.imported_from = imported_from
         self.import_author = import_author
         self.frame_index = frame_index
+        self.frame_range = frame_range  # inclusive [start, end], as the server expects
         self.units = units
         self.model_id = model_id
         if model_id is not None:
@@ -70,6 +72,7 @@ class CreateAnnotationDto:
             "identifier": self.identifier,
             "scope": self.scope,
             'frame_index': self.frame_index,
+            'frame_range': list(self.frame_range) if self.frame_range is not None else None,
             'annotation_worklist_id': self.annotation_worklist_id,
             'imported_from': self.imported_from,
             'import_author': self.import_author,

{datamint-2.40.0 → datamint-2.41.0}/datamint/api/endpoints/annotations_api.py

@@ -21,13 +21,14 @@ from PIL import Image
 from tqdm.auto import tqdm
 
 from datamint.api.dto import CreateAnnotationDto
+from datamint.api.dto.annotation_dto import _remove_none
 from datamint.entities import Resource
 from datamint.entities.annotations import (
     Annotation,
     AnnotationType,
     BoxAnnotation,
+    CategoryAnnotation,
     CoordinateSystem,
-    ImageClassification,
     LineAnnotation,
     NumericAnnotation,
     PointAnnotation,
@@ -1124,6 +1125,8 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
         """
         Create an image-level classification annotation.
 
+        Same as :meth:`add_category_annotation` without frames.
+
         Args:
             resource: The resource unique id or Resource instance.
             identifier: The annotation identifier/label.
@@ -1139,7 +1142,7 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
         Returns:
             The id of the created annotation.
         """
-        annotation = ImageClassification(
+        annotation = CategoryAnnotation(
             name=identifier,
             value=value,
             worklist_id=worklist_id,
@@ -1201,6 +1204,241 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
             raise TypeError('Expected a single annotation id for numeric annotation creation.')
         return created
 
+    @staticmethod
+    def _resolve_frame_scope(frame_index: int | None,
+                             frame_range: tuple[int, int] | None,
+                             ) -> tuple[str, tuple[int, int] | None]:
+        """Return the scope and the inclusive frame range expected by the server."""
+        if frame_index is not None and frame_range is not None:
+            raise ValueError('Pass either frame_index or frame_range, not both.')
+        if frame_range is None:
+            return ('image' if frame_index is None else 'frame'), None
+        start, end = frame_range
+        if start < 0 or end <= start:
+            raise ValueError(f'Invalid frame_range {frame_range}. Expected half-open (start, end) with 0 <= start < end.')
+        return 'frame', (start, end - 1)
+
+    def _add_value_annotation(self,
+                              annotation_type: AnnotationType,
+                              resource: str | Resource,
+                              identifier: str,
+                              value: str | None,
+                              frame_index: int | None,
+                              frame_range: tuple[int, int] | None,
+                              worklist_id: str | None,
+                              author_email: str | None,
+                              imported_from: str | None,
+                              model_id: str | None,
+                              source: str | None) -> str:
+        scope, inclusive_range = self._resolve_frame_scope(frame_index, frame_range)
+        dto = CreateAnnotationDto(
+            type=annotation_type,
+            identifier=identifier,
+            scope=scope,
+            value=value,
+            frame_index=frame_index,
+            frame_range=inclusive_range,
+            annotation_worklist_id=worklist_id,
+            import_author=author_email,
+            imported_from=imported_from,
+            model_id=model_id,
+            source=source,
+        )
+        created = self.create(resource, dto)
+        if not isinstance(created, str):
+            raise TypeError(f'Expected a single annotation id for {annotation_type.value} annotation creation.')
+        return created
+
+    def add_text_annotation(self,
+                            resource: str | Resource,
+                            identifier: str,
+                            value: str,
+                            frame_index: int | None = None,
+                            frame_range: tuple[int, int] | None = None,
+                            worklist_id: str | None = None,
+                            author_email: str | None = None,
+                            imported_from: str | None = None,
+                            model_id: str | None = None,
+                            source: str | None = 'imported') -> str:
+        """
+        Add a free-text annotation to a resource, for the whole image or for frames.
+
+        Args:
+            resource: The resource unique id or Resource instance.
+            identifier: The annotation identifier.
+            value: Any free text.
+            frame_index: A single frame (0-based). Makes the annotation frame-scoped.
+            frame_range: Half-open ``(start, end)`` frame range, 0-based, ``end`` not included.
+                Makes the annotation frame-scoped. Mutually exclusive with `frame_index`.
+            worklist_id: The annotation worklist unique id.
+            author_email: The email to consider as the author of the annotation.
+                If None, use the customer of the api key.
+            imported_from: The imported from source value.
+            model_id: The model unique id.
+            source: Annotation source tag.
+
+        Returns:
+            The id of the created annotation.
+
+        Example:
+            .. code-block:: python
+
+                api.annotations.add_text_annotation(resource, 'findings', 'small fracture line')
+                api.annotations.add_text_annotation(resource, 'findings', 'motion blur', frame_range=(10, 20))
+        """
+        return self._add_value_annotation(AnnotationType.TEXT, resource, identifier, value,
+                                          frame_index, frame_range, worklist_id, author_email,
+                                          imported_from, model_id, source)
+
+    def add_category_annotation(self,
+                                resource: str | Resource,
+                                identifier: str,
+                                value: str,
+                                frame_index: int | None = None,
+                                frame_range: tuple[int, int] | None = None,
+                                worklist_id: str | None = None,
+                                author_email: str | None = None,
+                                imported_from: str | None = None,
+                                model_id: str | None = None,
+                                source: str | None = 'imported') -> str:
+        """
+        Add a category annotation to a resource, for the whole image or for frames.
+
+        Args:
+            resource: The resource unique id or Resource instance.
+            identifier: The annotation identifier.
+            value: One of the category values set up in the project (e.g. 'Displaced').
+            frame_index: A single frame (0-based). Makes the annotation frame-scoped.
+            frame_range: Half-open ``(start, end)`` frame range, 0-based, ``end`` not included.
+                Makes the annotation frame-scoped. Mutually exclusive with `frame_index`.
+            worklist_id: The annotation worklist unique id.
+            author_email: The email to consider as the author of the annotation.
+                If None, use the customer of the api key.
+            imported_from: The imported from source value.
+            model_id: The model unique id.
+            source: Annotation source tag.
+
+        Returns:
+            The id of the created annotation.
+        """
+        return self._add_value_annotation(AnnotationType.CATEGORY, resource, identifier, value,
+                                          frame_index, frame_range, worklist_id, author_email,
+                                          imported_from, model_id, source)
+
+    def add_label_annotation(self,
+                             resource: str | Resource,
+                             identifier: str,
+                             frame_index: int | None = None,
+                             frame_range: tuple[int, int] | None = None,
+                             worklist_id: str | None = None,
+                             author_email: str | None = None,
+                             imported_from: str | None = None,
+                             model_id: str | None = None,
+                             source: str | None = 'imported') -> str:
+        """
+        Add a label annotation to a resource, for the whole image or for frames.
+        A label marks that something is present and carries no value.
+
+        Args:
+            resource: The resource unique id or Resource instance.
+            identifier: The label name (e.g. 'Fracture').
+            frame_index: A single frame (0-based). Makes the annotation frame-scoped.
+            frame_range: Half-open ``(start, end)`` frame range, 0-based, ``end`` not included.
+                Makes the annotation frame-scoped. Mutually exclusive with `frame_index`.
+            worklist_id: The annotation worklist unique id.
+            author_email: The email to consider as the author of the annotation.
+                If None, use the customer of the api key.
+            imported_from: The imported from source value.
+            model_id: The model unique id.
+            source: Annotation source tag.
+
+        Returns:
+            The id of the created annotation.
+        """
+        return self._add_value_annotation(AnnotationType.LABEL, resource, identifier, None,
+                                          frame_index, frame_range, worklist_id, author_email,
+                                          imported_from, model_id, source)
+
+    def set_frame_ranges(self,
+                         resource: str | Resource,
+                         identifier: str,
+                         type: AnnotationType | str,
+                         values: dict[str | float | None, Sequence[tuple[int, int]]],
+                         worklist_id: str | None = None,
+                         model_id: str | None = None,
+                         source: str | None = None) -> dict[str, Any]:
+        """
+        Replace all frame ranges of one track (resource + identifier + type + author + worklist).
+
+        Anything not in `values` is removed, so passing an empty dict clears the track.
+
+        Args:
+            resource: The resource unique id or Resource instance.
+            identifier: The annotation identifier.
+            type: One of 'text', 'category', 'integer', 'float' or 'label'.
+            values: Maps each value to its half-open ``(start, end)`` frame ranges, 0-based.
+                Use ``None`` as the key for a label, which carries no value.
+            worklist_id: The annotation worklist unique id. Omit for project-level tracks.
+            model_id: Registered model name. Only allowed for API keys.
+            source: Annotation source tag. Defaults from the auth context when omitted.
+
+        Returns:
+            The server response, with the ``created`` and ``deleted`` rows.
+
+        Example:
+            .. code-block:: python
+
+                api.annotations.set_frame_ranges(resource, 'position', 'category',
+                                                 {'Displaced': [(0, 10), (20, 31)],
+                                                  'Normal': [(10, 20)]})
+        """
+        type = type if isinstance(type, AnnotationType) else AnnotationType(type)
+        payload_values = []
+        for value, ranges in values.items():
+            item: dict[str, Any] = {'frame_ranges': [{'start': start, 'end': end} for start, end in ranges]}
+            if value is not None:
+                item['value'] = value
+            payload_values.append(item)
+
+        payload = _remove_none({
+            'identifier': identifier,
+            'type': type.value,
+            'annotation_worklist_id': worklist_id,
+            'values': payload_values,
+            'source': source,
+            'model_id': model_id,
+        })
+        resource_id = self._entid(resource)
+        resp = self._make_request('PUT',
+                                  f'{self.endpoint_base}/{resource_id}/frame-ranges',
+                                  json=payload)
+        return resp.json()
+
+    def get_frame_ranges(self,
+                         resource: str | Resource,
+                         worklist_id: str | None = None,
+                         created_by: str | None = None) -> list[dict[str, Any]]:
+        """
+        Get the frame-scoped classifications (text, category, integer, float, label) of a resource,
+        one record per identifier + value + author.
+
+        Args:
+            resource: The resource unique id or Resource instance.
+            worklist_id: Restrict to a worklist. Omit for project-level tracks.
+            created_by: Restrict to a single author (email).
+
+        Returns:
+            The server records, with ``frame_ranges`` as a list of half-open ``(start, end)`` tuples.
+        """
+        params = _remove_none({'annotation_worklist_id': worklist_id, 'created_by': created_by})
+        resource_id = self._entid(resource)
+        records = self._make_request('GET',
+                                     f'{self.endpoint_base}/{resource_id}/frame-ranges',
+                                     params=params).json()
+        for rec in records:
+            rec['frame_ranges'] = [(r['start'], r['end']) for r in rec.get('frame_ranges') or []]
+        return records
+
     def upload_predictions(
         self,
         resource: str | Resource,

{datamint-2.40.0 → datamint-2.41.0}/datamint/api/endpoints/deploy_model_api.py

@@ -1,7 +1,6 @@
 """API handler for model deployment endpoints."""
 import json
 import logging
-import re
 import threading
 import time
 from collections.abc import Callable, Generator
@@ -20,22 +19,6 @@ logger = logging.getLogger(__name__)
 
 _TERMINAL_STATUSES = frozenset({'completed', 'failed', 'cancelled', 'error'})
 
-
-def _model_name_to_image_name(model_name: str) -> str:
-    """Lowercase and clean a model name to match the Docker image name it was deployed as."""
-
-    parts = [p for p in model_name.split("/") if p]
-    if not parts:
-        return "image"
-    cleaned = []
-    for part in parts:
-        part = part.strip().lower()
-        part = re.sub(r"\s+", "_", part)
-        part = re.sub(r"[^a-z0-9._-]", "-", part)
-        part = part.strip("._-")
-        cleaned.append(part or "image")
-    return "/".join(cleaned)
-
 #: SSE event name carrying a single new build-log line
 _LOG_EVENT = 'log'
 #: SSE event name signalling that the log stream was closed by the server
@@ -231,7 +214,6 @@ class DeployModelApi(EntityBaseApi[DeployJob]):
 
     def remove_image(self, model_name: str, tag: str | None = None) -> dict:
         """Remove a deployed model image."""
-        model_name = _model_name_to_image_name(model_name)
         params = {}
         if tag:
             params['tag'] = tag
@@ -240,7 +222,6 @@ class DeployModelApi(EntityBaseApi[DeployJob]):
 
     def image_exists(self, model_name: str, tag: str = DEFAULT_DEPLOY_MODEL_ALIAS) -> bool:
         """Check if a model image exists."""
-        model_name = _model_name_to_image_name(model_name)
         params = {'tag': tag}
         response = self._make_request('GET', f'/{self.endpoint_base}/image/{model_name}/exists', params=params)
         return response.json().get('exists', False)

{datamint-2.40.0 → datamint-2.41.0}/datamint/client_cmd_tools/datamint_init.py

@@ -541,7 +541,7 @@ for class_dir in class_dirs:
     print(f"  '{class_name}': uploaded {len(uploaded)} images.")
 
     for res in uploaded:
-        api.annotations.create_image_classification(
+        api.annotations.add_category_annotation(
             resource=res,
             identifier=LABEL_NAME,
             value=class_name,
@@ -800,7 +800,7 @@ for resource in test_resources:
     pred_anns = predictions[0] if predictions else []
 
     for ann in pred_anns:
-        api.annotations.create_image_classification(
+        api.annotations.add_category_annotation(
             resource=resource,
             identifier=LABEL_NAME,
             value=ann.value,

{datamint-2.40.0 → datamint-2.41.0}/datamint/entities/annotations/__init__.py

@@ -1,12 +1,14 @@
 from .annotation import Annotation, _normalize_annotation_data
 from .box_annotation import BoxAnnotation
+from .category_annotation import CategoryAnnotation, ImageClassification
 from .geometry import BoxGeometry, CoordinateSystem, Geometry, LineGeometry, PointGeometry, RegionGeometry
-from .image_classification import ImageClassification
 from .image_segmentation import ImageSegmentation
+from .label_annotation import LabelAnnotation
 from .line_annotation import LineAnnotation
 from .numeric_annotation import NumericAnnotation
 from .point_annotation import PointAnnotation
 from .region_annotation import RegionAnnotation
+from .text_annotation import TextAnnotation
 from .types import AnnotationType
 from .volume_segmentation import VolumeSegmentation
 
@@ -18,7 +20,9 @@ def annotation_from_dict(data: dict) -> Annotation:
 
     * ``'segmentation'`` with a ``class_map`` → :class:`VolumeSegmentation`
     * ``'segmentation'`` without ``class_map`` → :class:`ImageSegmentation`
-    * ``'category'`` → :class:`ImageClassification`
+    * ``'category'`` → :class:`CategoryAnnotation`
+    * ``'text'`` → :class:`TextAnnotation`
+    * ``'label'`` → :class:`LabelAnnotation`
     * ``'integer'``/``'float'`` → :class:`NumericAnnotation`
     * ``'line'`` → :class:`LineAnnotation`
     * ``'square'`` → :class:`BoxAnnotation`
@@ -47,7 +51,13 @@ def annotation_from_dict(data: dict) -> Annotation:
         return ImageSegmentation(**normalized_data)
 
     if annotation_type in (AnnotationType.CATEGORY, AnnotationType.CATEGORY.value):
-        return ImageClassification(**normalized_data)
+        return CategoryAnnotation(**normalized_data)
+
+    if annotation_type in (AnnotationType.TEXT, AnnotationType.TEXT.value):
+        return TextAnnotation(**normalized_data)
+
+    if annotation_type in (AnnotationType.LABEL, AnnotationType.LABEL.value):
+        return LabelAnnotation(**normalized_data)
 
     if annotation_type in (AnnotationType.INTEGER, AnnotationType.FLOAT):
         return NumericAnnotation(**normalized_data)
@@ -72,10 +82,12 @@ __all__ = [
     "AnnotationType",
     "BoxAnnotation",
     "BoxGeometry",
+    "CategoryAnnotation",
     "CoordinateSystem",
     "Geometry",
     "ImageClassification",
     "ImageSegmentation",
+    "LabelAnnotation",
     "LineAnnotation",
     "LineGeometry",
     "NumericAnnotation",
@@ -83,6 +95,7 @@ __all__ = [
     "PointGeometry",
     "RegionAnnotation",
     "RegionGeometry",
+    "TextAnnotation",
     "VolumeSegmentation",
     "annotation_from_dict",
 ]

{datamint-2.40.0 → datamint-2.41.0}/datamint/entities/annotations/annotation.py

@@ -60,7 +60,7 @@ class AnnotationBase(BaseEntity):
     """Minimal base class for creating annotations.
 
     This class contains only the essential fields needed to create annotations.
-    Use this for creating specific annotation types like ImageClassification.
+    Use this for creating specific annotation types like CategoryAnnotation.
     """
 
     model_config = ConfigDict(populate_by_name=True)

datamint-2.40.0/datamint/entities/annotations/image_classification.py → datamint-2.41.0/datamint/entities/annotations/category_annotation.py

@@ -5,7 +5,7 @@ from typing import Any
 from .annotation import Annotation
 
 
-class ImageClassification(Annotation):
+class CategoryAnnotation(Annotation):
     def __init__(
         self,
         name: str | None = None,
@@ -37,3 +37,7 @@ class ImageClassification(Annotation):
         kwargs.setdefault('scope', 'image')
         kwargs.setdefault('annotation_type', 'category')
         super().__init__(**kwargs)
+
+
+# Backwards compatible name. Same class, not a subclass.
+ImageClassification = CategoryAnnotation

datamint-2.41.0/datamint/entities/annotations/image_classification.py

@@ -0,0 +1,3 @@
+from .category_annotation import CategoryAnnotation, ImageClassification
+
+__all__ = ["CategoryAnnotation", "ImageClassification"]

datamint-2.41.0/datamint/entities/annotations/label_annotation.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .annotation import Annotation
+from .types import AnnotationType
+
+
+class LabelAnnotation(Annotation):
+    def __init__(
+        self,
+        name: str | None = None,
+        confiability: float = 1.0,
+        worklist_id: str | None = None,
+        author_email: str | None = None,
+        imported_from: str | None = None,
+        model_id: str | None = None,
+        source: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        if name is not None:
+            kwargs.setdefault('identifier', name)
+        if worklist_id is not None:
+            kwargs.setdefault('annotation_worklist_id', worklist_id)
+        if author_email is not None:
+            kwargs.setdefault('import_author', author_email)
+        if imported_from is not None:
+            kwargs.setdefault('imported_from', imported_from)
+        if model_id is not None:
+            kwargs.setdefault('model_id', model_id)
+        if source is not None:
+            kwargs.setdefault('source', source)
+
+        kwargs.setdefault('confiability', confiability)
+        kwargs.setdefault('scope', 'image')
+        kwargs.setdefault('annotation_type', AnnotationType.LABEL)
+        super().__init__(**kwargs)

datamint-2.41.0/datamint/entities/annotations/text_annotation.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .annotation import Annotation
+from .types import AnnotationType
+
+
+class TextAnnotation(Annotation):
+    def __init__(
+        self,
+        name: str | None = None,
+        value: str | None = None,
+        confiability: float = 1.0,
+        worklist_id: str | None = None,
+        author_email: str | None = None,
+        imported_from: str | None = None,
+        model_id: str | None = None,
+        source: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        if name is not None:
+            kwargs.setdefault('identifier', name)
+        if value is not None:
+            kwargs.setdefault('text_value', value)
+        if worklist_id is not None:
+            kwargs.setdefault('annotation_worklist_id', worklist_id)
+        if author_email is not None:
+            kwargs.setdefault('import_author', author_email)
+        if imported_from is not None:
+            kwargs.setdefault('imported_from', imported_from)
+        if model_id is not None:
+            kwargs.setdefault('model_id', model_id)
+        if source is not None:
+            kwargs.setdefault('source', source)
+
+        kwargs.setdefault('confiability', confiability)
+        kwargs.setdefault('scope', 'image')
+        kwargs.setdefault('annotation_type', AnnotationType.TEXT)
+        super().__init__(**kwargs)

{datamint-2.40.0 → datamint-2.41.0}/datamint/entities/annotations/types.py

@@ -19,4 +19,6 @@ class AnnotationType(StrEnum):
     CATEGORY = 'category'
     LABEL = 'label'
     INTEGER = 'integer'
-    FLOAT = 'float'
+    FLOAT = 'float'
+    TEXT = 'text'
+    SPLINE = 'spline'

{datamint-2.40.0 → datamint-2.41.0}/datamint/examples/fracatlas_dataset.py

@@ -62,13 +62,13 @@ def create(project_name: str = _DATASET_NAME, api: Api | None = None) -> Project
     )
 
     for resource_id in tqdm(non_fractured_ids, desc='Uploading annotations'):
-        api.annotations.create_image_classification(
+        api.annotations.add_category_annotation(
             resource=resource_id,
             identifier=_LABEL_IDENTIFIER,
             value='no',
         )
     for resource_id in tqdm(fractured_ids, desc='Uploading annotations'):
-        api.annotations.create_image_classification(
+        api.annotations.add_category_annotation(
             resource=resource_id,
             identifier=_LABEL_IDENTIFIER,
             value='yes',

{datamint-2.40.0 → datamint-2.41.0}/datamint/lightning/trainers/lightning_modules/classification_module.py

@@ -13,7 +13,7 @@ from albumentations.pytorch import ToTensorV2
 from torch import Tensor, nn
 from torchmetrics import MetricCollection
 
-from datamint.entities.annotations import ImageClassification
+from datamint.entities.annotations import CategoryAnnotation
 from datamint.mlflow.flavors.task_type import TaskType
 
 from .base import DatamintLightningModule
@@ -158,7 +158,7 @@ class ClassificationModule(DatamintLightningModule):
         compute_uncertainty: bool = False,
         **kwargs: Any,
     ):
-        """Run classification inference, returning :class:`~datamint.entities.annotations.ImageClassification` per resource.
+        """Run classification inference, returning :class:`~datamint.entities.annotations.CategoryAnnotation` per resource.
 
         Args:
             compute_uncertainty: If ``True``, also compute a predictive-entropy
@@ -193,7 +193,7 @@ class ClassificationModule(DatamintLightningModule):
                 extra = {}
                 if compute_uncertainty:
                     extra['uncertainty'] = categorical_entropy(probs)[0].item()
-                all_preds.append([ImageClassification(
+                all_preds.append([CategoryAnnotation(
                     name=identifier, value=value,
                     confiability=confidence,
                     **extra,

{datamint-2.40.0 → datamint-2.41.0}/datamint/mlflow/flavors/model.py

@@ -15,7 +15,7 @@ from typing_extensions import override
 
 from datamint.entities.annotations import (
     Annotation,
-    ImageClassification,
+    CategoryAnnotation,
     ImageSegmentation,
 )
 from datamint.entities.annotations.annotation_spec import AnnotationSpec
@@ -34,7 +34,7 @@ logger = logging.getLogger(__name__)
 
 # Type aliases
 PredictionResult: TypeAlias = list[list[Annotation]]
-PredictionImageResult: TypeAlias = Sequence[Sequence[ImageSegmentation | ImageClassification]]
+PredictionImageResult: TypeAlias = Sequence[Sequence[ImageSegmentation | CategoryAnnotation]]
 
 
 def _move_torch_modules_to_device(obj: Any, device: str, _seen: set[int] | None = None) -> None:

{datamint-2.40.0 → datamint-2.41.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "datamint"
 description = "A library for interacting with the Datamint API, designed for efficient data management, processing and Deep Learning workflows."
-version = "2.40.0"
+version = "2.41.0"
 dynamic = ["dependencies"]
 requires-python = ">=3.10"
 readme = "README.md"