datamint 2.2.1__tar.gz → 2.3.0__tar.gz

{datamint-2.2.1 → datamint-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datamint
-Version: 2.2.1
+Version: 2.3.0
 Summary: A library for interacting with the Datamint API, designed for efficient data management, processing and Deep Learning workflows.
 Requires-Python: >=3.10
 Classifier: Programming Language :: Python :: 3

{datamint-2.2.1 → datamint-2.3.0}/datamint/api/client.py

@@ -1,10 +1,8 @@
 from typing import Optional
-import httpx
 from .base_api import ApiConfig
-from .endpoints import ProjectsApi, ResourcesApi, AnnotationsApi, ChannelsApi, UsersApi, DatasetsInfoApi
+from .endpoints import ProjectsApi, ResourcesApi, AnnotationsApi, ChannelsApi, UsersApi, DatasetsInfoApi, ModelsApi
 import datamint.configs
 from datamint.exceptions import DatamintException
-import asyncio
 
 
 class Api:
@@ -18,7 +16,8 @@ class Api:
         'annotations': AnnotationsApi,
         'channels': ChannelsApi,
         'users': UsersApi,
-        'datasets': DatasetsInfoApi
+        'datasets': DatasetsInfoApi,
+        'models': ModelsApi
     }
 
     def __init__(self,
@@ -73,19 +72,28 @@ class Api:
     @property
     def projects(self) -> ProjectsApi:
         return self._get_endpoint('projects')
+
     @property
     def resources(self) -> ResourcesApi:
         return self._get_endpoint('resources')
+
     @property
     def annotations(self) -> AnnotationsApi:
         return self._get_endpoint('annotations')
+
     @property
     def channels(self) -> ChannelsApi:
         return self._get_endpoint('channels')
+
     @property
     def users(self) -> UsersApi:
         return self._get_endpoint('users')
+
     @property
     def _datasetsinfo(self) -> DatasetsInfoApi:
         """Internal property to access DatasetsInfoApi."""
-        return self._get_endpoint('datasets')
+        return self._get_endpoint('datasets')
+
+    @property
+    def models(self) -> ModelsApi:
+        return self._get_endpoint('models')

{datamint-2.2.1 → datamint-2.3.0}/datamint/api/endpoints/__init__.py

@@ -6,6 +6,7 @@ from .projects_api import ProjectsApi
 from .resources_api import ResourcesApi
 from .users_api import UsersApi
 from .datasetsinfo_api import DatasetsInfoApi
+from .models_api import ModelsApi
 
 __all__ = [
     'AnnotationsApi',
@@ -13,5 +14,6 @@ __all__ = [
     'ProjectsApi',
     'ResourcesApi',
     'UsersApi',
-    'DatasetsInfoApi'
+    'DatasetsInfoApi',
+    'ModelsApi',
 ]

{datamint-2.2.1 → datamint-2.3.0}/datamint/api/endpoints/annotations_api.py

@@ -3,9 +3,9 @@ import httpx
 from datetime import date
 import logging
 from ..entity_base_api import ApiConfig, CreatableEntityApi, DeletableEntityApi
+from .models_api import ModelsApi
 from datamint.entities.annotation import Annotation
 from datamint.entities.resource import Resource
-from datamint.entities.project import Project
 from datamint.apihandler.dto.annotation_dto import AnnotationType, CreateAnnotationDto, LineGeometry, BoxGeometry, CoordinateSystem, Geometry
 import numpy as np
 import os
@@ -38,6 +38,7 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
             client: Optional HTTP client instance. If None, a new one will be created.
         """
         super().__init__(config, Annotation, 'annotations', client)
+        self._models_api = ModelsApi(config, client=client)
 
     def get_list(self,
                  resource: str | Resource | None = None,
@@ -69,7 +70,7 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
 
     async def _upload_segmentations_async(self,
                                           resource: str | Resource,
-                                          frame_index: int | Sequence [int] | None,
+                                          frame_index: int | Sequence[int] | None,
                                           file_path: str | np.ndarray,
                                           name: dict[int, str] | dict[tuple, str],
                                           imported_from: str | None = None,
@@ -78,7 +79,7 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
                                           worklist_id: str | None = None,
                                           model_id: str | None = None,
                                           transpose_segmentation: bool = False,
-                                          upload_volume: bool | str = 'auto'
+                                          upload_volume: bool | str = 'auto',
                                           ) -> Sequence[str]:
         """
         Upload segmentations asynchronously.
@@ -397,6 +398,7 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
                              worklist_id: str | None = None,
                              model_id: str | None = None,
                              transpose_segmentation: bool = False,
+                             ai_model_name: str | None = None
                              ) -> list[str]:
         """
         Upload segmentations to a resource.
@@ -425,6 +427,7 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
             worklist_id: The annotation worklist unique id.
             model_id: The model unique id.
             transpose_segmentation: Whether to transpose the segmentation or not.
+            ai_model_name: Optional AI model name to associate with the segmentation.
 
         Returns:
             List of segmentation unique ids.
@@ -453,6 +456,18 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
         if isinstance(file_path, str) and not os.path.exists(file_path):
             raise FileNotFoundError(f"File {file_path} not found.")
 
+        if ai_model_name is not None:
+            model_id = self._models_api.get_by_name(ai_model_name)
+            if model_id is None:
+                try:
+                    available_models = [model['name'] for model in self._models_api.get_all()]
+                except Exception:
+                    _LOGGER.warning("Could not fetch available AI models from the server.")
+                    raise ValueError(f"AI model with name '{ai_model_name}' not found. ")
+                raise ValueError(f"AI model with name '{ai_model_name}' not found. " +
+                                 f"Available models: {available_models}")
+            model_id = model_id['id']
+
         # Handle NIfTI files specially - upload as single volume
         if isinstance(file_path, str) and (file_path.endswith('.nii') or file_path.endswith('.nii.gz')):
             _LOGGER.info(f"Uploading NIfTI segmentation file: {file_path}")
@@ -472,7 +487,7 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
                 worklist_id=worklist_id,
                 model_id=model_id,
                 transpose_segmentation=transpose_segmentation,
-                upload_volume=True
+                upload_volume=True,
             )
             return loop.run_until_complete(task)
 
@@ -486,8 +501,8 @@ class AnnotationsApi(CreatableEntityApi[Annotation], DeletableEntityApi[Annotati
                 raise ValueError("frame_index list contains duplicate values.")
 
         if isinstance(frame_index, Sequence) and len(frame_index) == 1:
-            frame_index = frame_index[0] 
-        
+            frame_index = frame_index[0]
+
         nest_asyncio.apply()
         loop = asyncio.get_event_loop()
         task = self._upload_segmentations_async(

datamint-2.3.0/datamint/api/endpoints/models_api.py

@@ -0,0 +1,47 @@
+from typing import Sequence
+from ..entity_base_api import ApiConfig, BaseApi
+import httpx
+from datamint.exceptions import EntityAlreadyExistsError
+
+
+class ModelsApi(BaseApi):
+    """API handler for project-related endpoints."""
+
+    def __init__(self,
+                 config: ApiConfig,
+                 client: httpx.Client | None = None) -> None:
+        """Initialize the projects API handler.
+
+        Args:
+            config: API configuration containing base URL, API key, etc.
+            client: Optional HTTP client instance. If None, a new one will be created.
+        """
+        super().__init__(config, client=client)
+
+    def create(self,
+               name: str) -> dict:
+        json = {
+            'name': name
+        }
+
+        try:
+            response = self._make_request('POST',
+                                          'ai-models',
+                                          json=json)
+            return response.json()
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 409:
+                raise EntityAlreadyExistsError('ai-model', {'name': name})
+            raise
+
+    def get_all(self) -> Sequence[dict]:
+        response = self._make_request('GET',
+                                      'ai-models')
+        return response.json()
+
+    def get_by_name(self, name: str) -> dict | None:
+        models = self.get_all()
+        for model in models:
+            if model['name'] == name:
+                return model
+        return None

{datamint-2.2.1 → datamint-2.3.0}/datamint/exceptions.py

@@ -28,4 +28,25 @@ class ResourceNotFoundError(DatamintException):
         self.params = params
 
     def __str__(self):
-        return f"Resource '{self.resource_type}' not found for parameters: {self.params}"
+        return f"Resource '{self.resource_type}' not found for parameters: {self.params}"
+
+# Already existing (e.g, creating a project with a name that already exists)
+class EntityAlreadyExistsError(DatamintException):
+    """
+    Exception raised when trying to create an entity that already exists.
+    For instance, when creating a project with a name that already exists.
+    """
+
+    def __init__(self, entity_type: str, params: dict):
+        """Constructor.
+
+        Args:
+            entity_type: The type of entity that already exists.
+            params: Dict of params identifying the existing entity.
+        """
+        super().__init__()
+        self.entity_type = entity_type
+        self.params = params
+
+    def __str__(self) -> str:
+        return f"Entity '{self.entity_type}' already exists for parameters: {self.params}"

{datamint-2.2.1 → datamint-2.3.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.2.1"
+version = "2.3.0"
 dynamic = ["dependencies"]
 requires-python = ">=3.10"
 readme = "README.md"