datamint 1.2.4__tar.gz → 1.4.0__tar.gz

{datamint-1.2.4 → datamint-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: datamint
-Version: 1.2.4
+Version: 1.4.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
@@ -14,6 +14,7 @@ Requires-Dist: Deprecated (>=1.2.0)
 Requires-Dist: aiohttp (>=3.0.0,<4.0.0)
 Requires-Dist: aioresponses (>=0.7.8,<0.8.0) ; extra == "dev"
 Requires-Dist: albumentations (>=2.0.0)
+Requires-Dist: datamintapi (==0.0.*)
 Requires-Dist: humanize (>=4.0.0,<5.0.0)
 Requires-Dist: lazy-loader (>=0.3.0)
 Requires-Dist: lightning
@@ -52,13 +53,12 @@ See the full documentation at https://sonanceai.github.io/datamint-python-api/
 ## Installation
 
 Datamint requires Python 3.10+.
-You can install Datamint and its dependencies using pip
+You can install/update Datamint and its dependencies using pip
 
 ```bash
-pip install git+https://github.com/SonanceAI/datamint-python-api
+pip install -U datamint
 ```
 
-Soon we will be releasing the package on PyPi.
 We recommend that you install Datamint in a dedicated virtual environment, to avoid conflicting with your system packages.
 Create the enviroment once with `python3 -m venv datamint-env` and then activate it whenever you need it with:
 - `source datamint-env/bin/activate` (Linux/MAC)
@@ -95,7 +95,7 @@ os.environ["DATAMINT_API_KEY"] = "my_api_key"
 Specify API key in the |APIHandlerClass| constructor:
 
 ```python
-from datamintapi import APIHandler
+from datamint import APIHandler
 api = APIHandler(api_key='my_api_key')
 ```
 

{datamint-1.2.4 → datamint-1.4.0}/README.md

@@ -8,13 +8,12 @@ See the full documentation at https://sonanceai.github.io/datamint-python-api/
 ## Installation
 
 Datamint requires Python 3.10+.
-You can install Datamint and its dependencies using pip
+You can install/update Datamint and its dependencies using pip
 
 ```bash
-pip install git+https://github.com/SonanceAI/datamint-python-api
+pip install -U datamint
 ```
 
-Soon we will be releasing the package on PyPi.
 We recommend that you install Datamint in a dedicated virtual environment, to avoid conflicting with your system packages.
 Create the enviroment once with `python3 -m venv datamint-env` and then activate it whenever you need it with:
 - `source datamint-env/bin/activate` (Linux/MAC)
@@ -51,7 +50,7 @@ os.environ["DATAMINT_API_KEY"] = "my_api_key"
 Specify API key in the |APIHandlerClass| constructor:
 
 ```python
-from datamintapi import APIHandler
+from datamint import APIHandler
 api = APIHandler(api_key='my_api_key')
 ```
 

{datamint-1.2.4/datamintapi → datamint-1.4.0/datamint}/__init__.py

@@ -1,6 +1,7 @@
 """
-Datamint API is a Python package that provides a simple interface to the Datamint API.
+Datamint API package alias.
 """
+
 import importlib.metadata
 from typing import TYPE_CHECKING
 if TYPE_CHECKING:
@@ -21,5 +22,5 @@ else:
         },
     )
 
-__name__ = "datamintapi"
-__version__ = importlib.metadata.version('datamint')
+__name__ = "datamint"
+__version__ = importlib.metadata.version(__name__)

{datamint-1.2.4/datamintapi → datamint-1.4.0/datamint}/apihandler/annotation_api_handler.py

@@ -11,7 +11,7 @@ import asyncio
 import aiohttp
 from requests.exceptions import HTTPError
 from deprecated.sphinx import deprecated
-from .dto.annotation_dto import CreateAnnotationDto, LineGeometry, CoordinateSystem, AnnotationType
+from .dto.annotation_dto import CreateAnnotationDto, LineGeometry, BoxGeometry, CoordinateSystem, AnnotationType
 import pydicom
 
 _LOGGER = logging.getLogger(__name__)
@@ -353,7 +353,7 @@ class AnnotationAPIHandler(BaseAPIHandler):
                         author_email: Optional[str] = None,
                         model_id: Optional[str] = None,
                         project: Optional[str] = None,
-                        ):
+                        ) -> list[str]:
         """
         Add annotations to a resource.
 
@@ -415,6 +415,66 @@ class AnnotationAPIHandler(BaseAPIHandler):
 
         resp = self._run_request(request_params)
         self._check_errors_response_json(resp)
+        return resp.json()
+
+    def _create_geometry_annotation(self,
+                                    geometry: LineGeometry | BoxGeometry,
+                                    resource_id: str,
+                                    identifier: str,
+                                    frame_index: int | None = None,
+                                    project: Optional[str] = None,
+                                    worklist_id: Optional[str] = None,
+                                    imported_from: Optional[str] = None,
+                                    author_email: Optional[str] = None,
+                                    model_id: Optional[str] = None) -> list[str]:
+        """
+        Common method for creating geometry-based annotations.
+        
+        Args:
+            geometry: The geometry object (LineGeometry or BoxGeometry)
+            resource_id: The resource unique id
+            identifier: The annotation identifier
+            frame_index: The frame index of the annotation
+            project: The project unique id or name
+            worklist_id: The annotation worklist unique id
+            imported_from: The imported from source value
+            author_email: The email to consider as the author of the annotation
+            model_id: The model unique id
+        """
+        if project is not None and worklist_id is not None:
+            raise ValueError('Only one of project or worklist_id can be provided.')
+
+        if project is not None:
+            proj = self.get_project_by_name(project)
+            if 'error' in proj.keys():
+                raise DatamintException(f"Project {project} not found.")
+            worklist_id = proj['worklist_id']
+
+        anndto = CreateAnnotationDto(
+            type=geometry.type,
+            identifier=identifier,
+            scope='frame',
+            annotation_worklist_id=worklist_id,
+            value=None,
+            imported_from=imported_from,
+            import_author=author_email,
+            frame_index=frame_index,
+            geometry=geometry,
+            model_id=model_id,
+            is_model=model_id is not None,
+        )
+
+        json_data = anndto.to_dict()
+
+        request_params = {
+            'method': 'POST',
+            'url': f'{self.root_url}/annotations/{resource_id}/annotations',
+            'json': [json_data]
+        }
+
+        resp = self._run_request(request_params)
+        self._check_errors_response_json(resp)
+        return resp.json()
 
     def add_line_annotation(self,
                             point1: tuple[int, int] | tuple[float, float, float],
@@ -428,7 +488,7 @@ class AnnotationAPIHandler(BaseAPIHandler):
                             worklist_id: Optional[str] = None,
                             imported_from: Optional[str] = None,
                             author_email: Optional[str] = None,
-                            model_id: Optional[str] = None):
+                            model_id: Optional[str] = None) -> list[str]:
         """
         Add a line annotation to a resource.
 
@@ -466,12 +526,6 @@ class AnnotationAPIHandler(BaseAPIHandler):
         if project is not None and worklist_id is not None:
             raise ValueError('Only one of project or worklist_id can be provided.')
 
-        if project is not None:
-            proj = self.get_project_by_name(project)
-            if 'error' in proj.keys():
-                raise DatamintException(f"Project {project} not found.")
-            worklist_id = proj['worklist_id']
-
         if coords_system == 'pixel':
             if dicom_metadata is None:
                 point1 = (point1[0], point1[1], frame_index)
@@ -486,30 +540,87 @@ class AnnotationAPIHandler(BaseAPIHandler):
         else:
             raise ValueError(f"Unknown coordinate system: {coords_system}")
 
-        anndto = CreateAnnotationDto(
-            type=AnnotationType.LINE,
+        return self._create_geometry_annotation(
+            geometry=geom,
+            resource_id=resource_id,
             identifier=identifier,
-            scope='frame',
-            annotation_worklist_id=worklist_id,
-            value=None,
-            imported_from=imported_from,
-            import_author=author_email,
             frame_index=frame_index,
-            geometry=geom,
-            model_id=model_id,
-            is_model=model_id is not None,
+            project=project,
+            worklist_id=worklist_id,
+            imported_from=imported_from,
+            author_email=author_email,
+            model_id=model_id
         )
 
-        json_data = anndto.to_dict()
+    def add_box_annotation(self,
+                           point1: tuple[int, int] | tuple[float, float, float],
+                           point2: tuple[int, int] | tuple[float, float, float],
+                           resource_id: str,
+                           identifier: str,
+                           frame_index: int | None = None,
+                           dicom_metadata: pydicom.Dataset | str | None = None,
+                           coords_system: CoordinateSystem = 'pixel',
+                           project: Optional[str] = None,
+                           worklist_id: Optional[str] = None,
+                           imported_from: Optional[str] = None,
+                           author_email: Optional[str] = None,
+                           model_id: Optional[str] = None):
+        """
+        Add a box annotation to a resource.
 
-        request_params = {
-            'method': 'POST',
-            'url': f'{self.root_url}/annotations/{resource_id}/annotations',
-            'json': [json_data]
-        }
+        Args:
+            point1: The first corner point of the box. Can be a 2d or 3d point.
+                If `coords_system` is 'pixel', it must be a 2d point representing pixel coordinates.
+                If `coords_system` is 'patient', it must be a 3d point representing patient coordinates.
+            point2: The opposite diagonal corner point of the box. See `point1` for more details.
+            resource_id: The resource unique id.
+            identifier: The annotation identifier, also known as the annotation's label.
+            frame_index: The frame index of the annotation.
+            dicom_metadata: The DICOM metadata of the image. If provided, coordinates will be converted
+                automatically using the DICOM metadata.
+            coords_system: The coordinate system of the points. Can be 'pixel' or 'patient'.
+                If 'pixel', points are in pixel coordinates. If 'patient', points are in patient coordinates.
+            project: The project unique id or name.
+            worklist_id: The annotation worklist unique id. Optional.
+            imported_from: The imported from source value.
+            author_email: The email to consider as the author of the annotation. If None, uses the API key customer.
+            model_id: The model unique id. Optional.
 
-        resp = self._run_request(request_params)
-        self._check_errors_response_json(resp)
+        Example:
+            .. code-block:: python
+
+                res_id = 'aa93813c-cef0-4edd-a45c-85d4a8f1ad0d'
+                api.add_box_annotation([10, 10], (50, 40),
+                                       resource_id=res_id,
+                                       identifier='BoundingBox1',
+                                       frame_index=2,
+                                       project='Example Project')
+        """
+        if coords_system == 'pixel':
+            if dicom_metadata is None:
+                point1 = (point1[0], point1[1], frame_index)
+                point2 = (point2[0], point2[1], frame_index)
+                geom = BoxGeometry(point1, point2)
+            else:
+                if isinstance(dicom_metadata, str):
+                    dicom_metadata = pydicom.dcmread(dicom_metadata)
+                geom = BoxGeometry.from_dicom(dicom_metadata, point1, point2, slice_index=frame_index)
+        elif coords_system == 'patient':
+            geom = BoxGeometry(point1, point2)
+        else:
+            raise ValueError(f"Unknown coordinate system: {coords_system}")
+
+        return self._create_geometry_annotation(
+            geometry=geom,
+            resource_id=resource_id,
+            identifier=identifier,
+            frame_index=frame_index,
+            project=project,
+            worklist_id=worklist_id,
+            imported_from=imported_from,
+            author_email=author_email,
+            model_id=model_id
+        )
 
     @deprecated(version='0.12.1', reason='Use :meth:`~get_annotations` instead with `resource_id` parameter.')
     def get_resource_annotations(self,
@@ -541,7 +652,7 @@ class AnnotationAPIHandler(BaseAPIHandler):
 
         Args:
             resource_id (Optional[str]): The resource unique id.
-            annotation_type (Optional[str]): The annotation type. See :class:`~datamintapi.dto.annotation_dto.AnnotationType`.
+            annotation_type (Optional[str]): The annotation type. See :class:`~datamint.dto.annotation_dto.AnnotationType`.
             annotator_email (Optional[str]): The annotator email.
             date_from (Optional[date]): The start date.
             date_to (Optional[date]): The end date.

{datamint-1.2.4/datamintapi → datamint-1.4.0/datamint}/apihandler/api_handler.py

@@ -9,7 +9,7 @@ class APIHandler(RootAPIHandler, ExperimentAPIHandler, AnnotationAPIHandler):
 
     .. code-block:: python
     
-        from datamintapi import APIHandler
+        from datamint import APIHandler
         api = APIHandler()
     """
     pass

{datamint-1.2.4/datamintapi → datamint-1.4.0/datamint}/apihandler/base_api_handler.py

@@ -13,7 +13,7 @@ from io import BytesIO
 import cv2
 import nibabel as nib
 from nibabel.filebasedimages import FileBasedImage as nib_FileBasedImage
-from datamintapi import configs
+from datamint import configs
 from functools import wraps
 
 _LOGGER = logging.getLogger(__name__)

{datamint-1.2.4/datamintapi → datamint-1.4.0/datamint}/apihandler/dto/annotation_dto.py

@@ -18,7 +18,7 @@ import json
 from typing import Any, TypeAlias, Literal
 import logging
 from enum import Enum
-from datamintapi.utils.dicom_utils import pixel_to_patient
+from datamint.utils.dicom_utils import pixel_to_patient
 import pydicom
 import numpy as np
 
@@ -97,6 +97,56 @@ class LineGeometry(Geometry):
         return LineGeometry(new_point1, new_point2)
 
 
+class BoxGeometry(Geometry):
+    def __init__(self, point1: tuple[float, float, float],
+                 point2: tuple[float, float, float]):
+        """
+        Create a box geometry from two diagonal corner points.
+
+        Args:
+            point1: First corner point (x, y, z) or (x, y, frame_index)
+            point2: Opposite diagonal corner point (x, y, z) or (x, y, frame_index)
+        """
+        super().__init__(AnnotationType.SQUARE)  # Using SQUARE as the box type
+        if isinstance(point1, np.ndarray):
+            point1 = point1.tolist()
+        if isinstance(point2, np.ndarray):
+            point2 = point2.tolist()
+        self.point1 = point1
+        self.point2 = point2
+
+    def to_dict(self) -> dict:
+        return {
+            'points': [self.point1, self.point2],
+        }
+
+    @staticmethod
+    def from_dicom(ds: pydicom.Dataset,
+                   point1: tuple[int, int],
+                   point2: tuple[int, int],
+                   slice_index: int | None = None) -> 'BoxGeometry':
+        """
+        Create a box geometry from DICOM pixel coordinates.
+
+        Args:
+            ds: DICOM dataset containing spatial metadata
+            point1: First corner in pixel coordinates (x, y)
+            point2: Opposite corner in pixel coordinates (x, y)
+            slice_index: The slice/frame index for 3D positioning
+
+        Returns:
+            BoxGeometry with patient coordinate points
+        """
+        pixel_x1, pixel_y1 = point1
+        pixel_x2, pixel_y2 = point2
+
+        new_point1 = pixel_to_patient(ds, pixel_x1, pixel_y1,
+                                      slice_index=slice_index)
+        new_point2 = pixel_to_patient(ds, pixel_x2, pixel_y2,
+                                      slice_index=slice_index)
+        return BoxGeometry(new_point1, new_point2)
+
+
 class CreateAnnotationDto:
     def __init__(self,
                  type: AnnotationType | str,

{datamint-1.2.4/datamintapi → datamint-1.4.0/datamint}/apihandler/exp_api_handler.py

@@ -1,4 +1,4 @@
-from datamintapi.apihandler.base_api_handler import BaseAPIHandler
+from datamint.apihandler.base_api_handler import BaseAPIHandler
 from typing import Optional, Dict, List, Union, Any
 import json
 import logging

{datamint-1.2.4/datamintapi → datamint-1.4.0/datamint}/apihandler/root_api_handler.py

@@ -6,8 +6,8 @@ from requests.exceptions import HTTPError
 import logging
 import asyncio
 import aiohttp
-from datamintapi.utils.dicom_utils import anonymize_dicom, to_bytesio, is_dicom
-from datamintapi.utils import dicom_utils
+from datamint.utils.dicom_utils import anonymize_dicom, to_bytesio, is_dicom
+from datamint.utils import dicom_utils
 import pydicom
 from pathlib import Path
 from datetime import date
@@ -15,7 +15,7 @@ import mimetypes
 from PIL import Image
 import cv2
 from nibabel.filebasedimages import FileBasedImage as nib_FileBasedImage
-from datamintapi import configs
+from datamint import configs
 from .base_api_handler import BaseAPIHandler, DatamintException, ResourceNotFoundError, ResourceFields, ResourceStatus
 from deprecated.sphinx import deprecated
 import json
@@ -63,6 +63,7 @@ class RootAPIHandler(BaseAPIHandler):
                                             session=None,
                                             modality: Optional[str] = None,
                                             publish: bool = False,
+                                            metadata_file: Optional[str] = None,
                                             ) -> str:
         if _is_io_object(file_path):
             name = file_path.name
@@ -97,6 +98,8 @@ class RootAPIHandler(BaseAPIHandler):
             is_a_dicom_file = is_dicom(name) or is_dicom(file_path)
             if is_a_dicom_file:
                 mimetype = 'application/dicom'
+            elif name.endswith('.nii') or name.endswith('.nii.gz'):
+                mimetype = 'application/x-nifti'
 
         filename = os.path.basename(name)
         _LOGGER.debug(f"File name '{filename}' mimetype: {mimetype}")
@@ -115,6 +118,25 @@ class RootAPIHandler(BaseAPIHandler):
             f = _open_io(file_path)
 
         try:
+            metadata_content = None
+            metadata_dict = None
+            if metadata_file is not None:
+                try:
+                    with open(metadata_file, 'r') as metadata_f:
+                        metadata_content = metadata_f.read()
+                        metadata_dict = json.loads(metadata_content)
+                        metadata_dict_lower = {k.lower(): v for k, v in metadata_dict.items() if isinstance(k, str)}
+                        try:
+                            if modality is None:
+                                if 'modality' in metadata_dict_lower:
+                                    modality = metadata_dict_lower['modality']
+                        except Exception as e:
+                            _LOGGER.debug(f"Failed to extract modality from metadata file {metadata_file}: {e}")
+                            _LOGGER.debug(f"Metadata dict: {metadata_dict}")
+                except Exception as e:
+                    _LOGGER.warning(f"Failed to read metadata file {metadata_file}: {e}")
+
+
             form = aiohttp.FormData()
             url = self._get_endpoint_url(RootAPIHandler.ENDPOINT_RESOURCES)
             file_key = 'resource'
@@ -134,6 +156,14 @@ class RootAPIHandler(BaseAPIHandler):
                 tags = ','.join([l.strip() for l in tags])
                 form.add_field('tags', tags)
 
+            # Add JSON metadata if provided
+            if metadata_content is not None:
+                try:
+                    _LOGGER.debug(f"Adding metadata from {metadata_file}")
+                    form.add_field('metadata', metadata_content, content_type='application/json')
+                except Exception as e:
+                    _LOGGER.warning(f"Failed to read metadata file {metadata_file}: {e}")
+
             request_params = {
                 'method': 'POST',
                 'url': url,
@@ -170,6 +200,7 @@ class RootAPIHandler(BaseAPIHandler):
                                       publish: bool = False,
                                       segmentation_files: Optional[list[dict]] = None,
                                       transpose_segmentation: bool = False,
+                                      metadata_files: Optional[list[Optional[str]]] = None,
                                       ) -> list[str]:
         if on_error not in ['raise', 'skip']:
             raise ValueError("on_error must be either 'raise' or 'skip'")
@@ -177,8 +208,11 @@ class RootAPIHandler(BaseAPIHandler):
         if segmentation_files is None:
             segmentation_files = _infinite_gen(None)
 
+        if metadata_files is None:
+            metadata_files = _infinite_gen(None)
+
         async with aiohttp.ClientSession() as session:
-            async def __upload_single_resource(file_path, segfiles: dict):
+            async def __upload_single_resource(file_path, segfiles: dict, metadata_file: Optional[str]):
                 async with self.semaphore:
                     rid = await self._upload_single_resource_async(
                         file_path=file_path,
@@ -191,6 +225,7 @@ class RootAPIHandler(BaseAPIHandler):
                         channel=channel,
                         modality=modality,
                         publish=publish,
+                        metadata_file=metadata_file,
                     )
                     if segfiles is not None:
                         fpaths = segfiles['files']
@@ -208,7 +243,8 @@ class RootAPIHandler(BaseAPIHandler):
                                                                        transpose_segmentation=transpose_segmentation)
                     return rid
 
-            tasks = [__upload_single_resource(f, segfiles) for f, segfiles in zip(files_path, segmentation_files)]
+            tasks = [__upload_single_resource(f, segfiles, metadata_file)
+                     for f, segfiles, metadata_file in zip(files_path, segmentation_files, metadata_files)]
             return await asyncio.gather(*tasks, return_exceptions=on_error == 'skip')
 
     def _assemble_dicoms(self, files_path: Sequence[str | IO]) -> tuple[Sequence[str | IO], bool]:
@@ -248,7 +284,8 @@ class RootAPIHandler(BaseAPIHandler):
                          segmentation_files: Optional[list[Union[list[str], dict]]] = None,
                          transpose_segmentation: bool = False,
                          modality: Optional[str] = None,
-                         assemble_dicoms: bool = True
+                         assemble_dicoms: bool = True,
+                         metadata_files: Optional[list[Optional[str]]] = None
                          ) -> list[str | Exception] | str | Exception:
         """
         Upload resources.
@@ -274,6 +311,7 @@ class RootAPIHandler(BaseAPIHandler):
             transpose_segmentation (bool): Whether to transpose the segmentation files or not.
             modality (Optional[str]): The modality of the resources.
             assemble_dicoms (bool): Whether to assemble the dicom files or not based on the SOPInstanceUID and InstanceNumber attributes.
+            metadata_files (Optional[list[Optional[str]]]): JSON metadata files to include with each resource.
 
         Raises:
             ResourceNotFoundError: If `publish_to` is supplied, and the project does not exists.
@@ -319,6 +357,7 @@ class RootAPIHandler(BaseAPIHandler):
                                             segmentation_files=segmentation_files,
                                             transpose_segmentation=transpose_segmentation,
                                             modality=modality,
+                                            metadata_files=metadata_files,
                                             )
 
         resource_ids = loop.run_until_complete(task)
@@ -690,13 +729,13 @@ class RootAPIHandler(BaseAPIHandler):
                           'url': url}
         try:
             response = self._run_request(request_params)
-            
+
             # Get mimetype if needed for auto_convert or add_extension
             mimetype = None
             if auto_convert or add_extension:
                 resource_info = self.get_resources_by_ids(resource_id)
                 mimetype = resource_info['mimetype']
-            
+
             if auto_convert:
                 try:
                     resource_file = BaseAPIHandler.convert_format(response.content,

{datamint-1.2.4/datamintapi → datamint-1.4.0/datamint}/client_cmd_tools/datamint_config.py

@@ -1,7 +1,7 @@
 import argparse
 import logging
-from datamintapi import configs
-from datamintapi.utils.logging_utils import load_cmdline_logging_config
+from datamint import configs
+from datamint.utils.logging_utils import load_cmdline_logging_config
 
 # Create two loggings: one for the user and one for the developer
 _LOGGER = logging.getLogger(__name__)
@@ -79,7 +79,7 @@ def configure_api_key():
 def test_connection():
     """Test the API connection with current settings."""
     try:
-        from datamintapi import APIHandler
+        from datamint import APIHandler
         _USER_LOGGER.info("🔄 Testing connection...")
         api = APIHandler()
         # Simple test - try to get projects

{datamint-1.2.4/datamintapi → datamint-1.4.0/datamint}/client_cmd_tools/datamint_upload.py

@@ -1,18 +1,18 @@
 import argparse
-from datamintapi.apihandler.api_handler import APIHandler
+from datamint.apihandler.api_handler import APIHandler
 import os
 from humanize import naturalsize
 import logging
 from pathlib import Path
 import sys
-from datamintapi.utils.dicom_utils import is_dicom
+from datamint.utils.dicom_utils import is_dicom
 import fnmatch
 from typing import Sequence, Generator, Optional, Any
 from collections import defaultdict
-from datamintapi import __version__ as datamintapi_version
-from datamintapi import configs
-from datamintapi.client_cmd_tools.datamint_config import ask_api_key
-from datamintapi.utils.logging_utils import load_cmdline_logging_config
+from datamint import __version__ as datamint_version
+from datamint import configs
+from datamint.client_cmd_tools.datamint_config import ask_api_key
+from datamint.utils.logging_utils import load_cmdline_logging_config
 import yaml
 
 # Create two loggings: one for the user and one for the developer
@@ -256,12 +256,86 @@ def _find_segmentation_files(segmentation_root_path: str,
     return segmentation_files
 
 
-def _parse_args() -> tuple[Any, list, Optional[list[dict]]]:
+def _find_json_metadata(file_path: str | Path) -> Optional[str]:
+    """
+    Find a JSON file with the same base name as the given file.
+
+    Args:
+        file_path (str): Path to the main file (e.g., NIFTI file)
+
+    Returns:
+        Optional[str]: Path to the JSON metadata file if found, None otherwise
+    """
+    file_path = Path(file_path)
+    json_path = file_path.with_suffix('.json')
+
+    if json_path.exists() and json_path.is_file():
+        _LOGGER.debug(f"Found JSON metadata file: {json_path}")
+        return str(json_path)
+
+    return None
+
+
+def _collect_metadata_files(files_path: list[str], auto_detect_json: bool) -> tuple[list, list[str]]:
+    """
+    Collect JSON metadata files for the given files and filter them from main files list.
+
+    Args:
+        files_path (list[str]): List of file paths
+        auto_detect_json (bool): Whether to auto-detect JSON metadata files
+
+    Returns:
+        tuple[list[Optional[str]], list[str]]: Tuple of (metadata file paths, filtered files_path)
+            - metadata file paths: List of metadata file paths (None if no metadata found)
+            - filtered files_path: Original files_path with JSON metadata files removed
+    """
+    if not auto_detect_json:
+        return [None] * len(files_path), files_path
+
+    metadata_files = []
+    used_json_files = set()
+    nifti_extensions = ['.nii', '.nii.gz']
+
+    for file_path in files_path:
+        # Check if this is a NIFTI file
+        if any(file_path.endswith(ext) for ext in nifti_extensions):
+            json_file = _find_json_metadata(file_path)
+            metadata_files.append(json_file)
+            if json_file is not None:
+                used_json_files.add(json_file)
+        else:
+            metadata_files.append(None)
+
+    # Filter out JSON files that are being used as metadata from the main files list
+    filtered_files_path = [f for f in files_path if f not in used_json_files]
+
+    # Update metadata_files to match the filtered list
+    if used_json_files:
+        _LOGGER.debug(f"Filtering out {len(used_json_files)} JSON metadata files from main upload list")
+        filtered_metadata_files = []
+        filtered_file_index = 0
+
+        for original_file in files_path:
+            if original_file not in used_json_files:
+                filtered_metadata_files.append(metadata_files[files_path.index(original_file)])
+                filtered_file_index += 1
+
+        metadata_files = filtered_metadata_files
+
+    return metadata_files, filtered_files_path
+
+
+def _parse_args() -> tuple[Any, list, Optional[list[dict]], Optional[list[str]]]:
     parser = argparse.ArgumentParser(
         description='DatamintAPI command line tool for uploading DICOM files and other resources')
-    parser.add_argument('--path', type=_is_valid_path_argparse, metavar="FILE",
-                        required=True,
+
+    # Add positional argument for path
+    parser.add_argument('path', nargs='?', type=_is_valid_path_argparse, metavar="PATH",
                         help='Path to the resource file(s) or a directory')
+
+    # Keep the --path option for backward compatibility, but make it optional
+    parser.add_argument('--path', dest='path_flag', type=_is_valid_path_argparse, metavar="FILE",
+                        help='Path to the resource file(s) or a directory (alternative to positional argument)')
     parser.add_argument('-r', '--recursive', nargs='?', const=-1,  # -1 means infinite
                         type=int,
                         help='Recurse folders looking for DICOMs. If a number is passed, recurse that number of levels.')
@@ -302,9 +376,28 @@ def _parse_args() -> tuple[Any, list, Optional[list[dict]]]:
                         help='Automatically answer yes to all prompts')
     parser.add_argument('--transpose-segmentation', action='store_true', default=False,
                         help='Transpose the segmentation dimensions to match the image dimensions')
-    parser.add_argument('--version', action='version', version=f'%(prog)s {datamintapi_version}')
+    parser.add_argument('--auto-detect-json', action='store_true', default=True,
+                        help='Automatically detect and include JSON metadata files with the same base name as NIFTI files')
+    parser.add_argument('--no-auto-detect-json', dest='auto_detect_json', action='store_false',
+                        help='Disable automatic detection of JSON metadata files (default behavior)')
+    parser.add_argument('--version', action='version', version=f'%(prog)s {datamint_version}')
     parser.add_argument('--verbose', action='store_true', help='Print debug messages', default=False)
     args = parser.parse_args()
+
+    # Handle path argument priority: positional takes precedence over --path flag
+    if args.path is not None and args.path_flag is not None:
+        _USER_LOGGER.warning("Both positional path and --path flag provided. Using positional argument.")
+        final_path = args.path
+    elif args.path is not None:
+        final_path = args.path
+    elif args.path_flag is not None:
+        final_path = args.path_flag
+    else:
+        parser.error("Path argument is required. Provide it as a positional argument or use --path flag.")
+
+    # Replace args.path with the final resolved path for consistency
+    args.path = final_path
+
     if args.verbose:
         # Get the console handler and set to debug
         logging.getLogger().handlers[0].setLevel(logging.DEBUG)
@@ -319,7 +412,6 @@ def _parse_args() -> tuple[Any, list, Optional[list[dict]]]:
         raise ValueError("--include-extensions and --exclude-extensions are mutually exclusive.")
 
     try:
-
         if os.path.isfile(args.path):
             file_path = [args.path]
             if args.recursive is not None:
@@ -337,6 +429,12 @@ def _parse_args() -> tuple[Any, list, Optional[list[dict]]]:
         if len(file_path) == 0:
             raise ValueError(f"No valid file was found in {args.path}")
 
+        # Collect JSON metadata files and filter them from main files list
+        metadata_files, file_path = _collect_metadata_files(file_path, args.auto_detect_json)
+
+        if len(file_path) == 0:
+            raise ValueError(f"No valid non-metadata files found in {args.path}")
+
         if args.segmentation_names is not None:
             with open(args.segmentation_names, 'r') as f:
                 segmentation_names = yaml.safe_load(f)
@@ -360,7 +458,7 @@ def _parse_args() -> tuple[Any, list, Optional[list[dict]]]:
             raise ValueError("Cannot use both --tag and --label. Use --tag instead. --label is deprecated.")
         args.tag = args.tag if args.tag is not None else args.label
 
-        return args, file_path, segmentation_files
+        return args, file_path, segmentation_files, metadata_files
 
     except Exception as e:
         if args.verbose:
@@ -371,6 +469,7 @@ def _parse_args() -> tuple[Any, list, Optional[list[dict]]]:
 def print_input_summary(files_path: list[str],
                         args,
                         segfiles: Optional[list[dict]],
+                        metadata_files: Optional[list[str]] = None,
                         include_extensions=None):
     ### Create a summary of the upload ###
     total_files = len(files_path)
@@ -397,6 +496,7 @@ def print_input_summary(files_path: list[str],
         if ext == '':
             ext = 'no extension'
         _USER_LOGGER.info(f"\t{ext}: {count}")
+    # Check for multiple extensions
     if len(ext_counts) > 1 and include_extensions is None:
         _USER_LOGGER.warning("Multiple file extensions found!" +
                              " Make sure you are uploading the correct files.")
@@ -419,6 +519,13 @@ def print_input_summary(files_path: list[str],
             else:
                 _USER_LOGGER.info(msg)
 
+    if metadata_files is not None:
+        num_metadata_files = sum([1 if metadata is not None else 0 for metadata in metadata_files])
+        if num_metadata_files > 0:
+            msg = f"Number of files with JSON metadata: {num_metadata_files} ({num_metadata_files / total_files:.0%})"
+            _USER_LOGGER.info(msg)
+            # TODO: Could add validation to ensure JSON metadata files contain valid DICOM metadata structure
+
 
 def print_results_summary(files_path: list[str],
                           results: list[str | Exception]):
@@ -441,7 +548,7 @@ def main():
     load_cmdline_logging_config()
 
     try:
-        args, files_path, segfiles = _parse_args()
+        args, files_path, segfiles, metadata_files = _parse_args()
     except Exception as e:
         _USER_LOGGER.error(f'Error validating arguments. {e}')
         return
@@ -449,6 +556,7 @@ def main():
     print_input_summary(files_path,
                         args=args,
                         segfiles=segfiles,
+                        metadata_files=metadata_files,
                         include_extensions=args.include_extensions)
 
     if not args.yes:
@@ -471,7 +579,8 @@ def main():
                                            publish=args.publish,
                                            segmentation_files=segfiles,
                                            transpose_segmentation=args.transpose_segmentation,
-                                           assemble_dicoms=True
+                                           assemble_dicoms=True,
+                                           metadata_files=metadata_files
                                            )
     _USER_LOGGER.info('Upload finished!')
     _LOGGER.debug(f"Number of results: {len(results)}")

{datamint-1.2.4/datamintapi → datamint-1.4.0/datamint}/dataset/base_dataset.py

@@ -8,13 +8,13 @@ import json
 import yaml
 import pydicom
 import numpy as np
-from datamintapi import configs
+from datamint import configs
 from torch.utils.data import DataLoader
 import torch
-from datamintapi.apihandler.base_api_handler import DatamintException
-from datamintapi.utils.dicom_utils import is_dicom
+from datamint.apihandler.base_api_handler import DatamintException
+from datamint.utils.dicom_utils import is_dicom
 import cv2
-from datamintapi.utils.io_utils import read_array_normalized
+from datamint.utils.io_utils import read_array_normalized
 from deprecated import deprecated
 from datetime import datetime
 
@@ -79,7 +79,7 @@ class DatamintBaseDataset:
                  include_frame_label_names: Optional[list[str]] = None,
                  exclude_frame_label_names: Optional[list[str]] = None
                  ):
-        from datamintapi.apihandler.api_handler import APIHandler
+        from datamint.apihandler.api_handler import APIHandler
         
         if project_name is None:
             raise ValueError("project_name is required.")

{datamint-1.2.4/datamintapi → datamint-1.4.0/datamint}/dataset/dataset.py

@@ -17,7 +17,7 @@ class DatamintDataset(DatamintBaseDataset):
     In addition to that, it has functionality to better process annotations and segmentations.
 
     .. note:: 
-        Import using ``from datamintapi import Dataset``.
+        Import using ``from datamint import Dataset``.
 
     Args:
         root: Root directory of dataset where data already exists or will be downloaded.

{datamint-1.2.4/datamintapi → datamint-1.4.0/datamint}/examples/example_projects.py

@@ -1,6 +1,6 @@
 import requests
 import io
-from datamintapi import APIHandler
+from datamint import APIHandler
 import logging
 from PIL import Image
 import numpy as np

{datamint-1.2.4/datamintapi → datamint-1.4.0/datamint}/experiment/_patcher.py

@@ -486,7 +486,7 @@ def initialize_automatic_logging(enable_rich_logging: bool = True):
     # check if RichHandler is already in the handlers
     if enable_rich_logging and not any(isinstance(h, RichHandler) for h in logging.getLogger().handlers):
         logging.getLogger().handlers.append(RichHandler())  # set rich logging handler for the root logger
-    # logging.getLogger("datamintapi").setLevel(logging.INFO)
+    # logging.getLogger("datamint").setLevel(logging.INFO)
 
     pytorch_patcher = PytorchPatcher()
 

{datamint-1.2.4/datamintapi → datamint-1.4.0/datamint}/experiment/experiment.py

@@ -1,14 +1,14 @@
 import logging
-from datamintapi.apihandler.api_handler import APIHandler
-from datamintapi.apihandler.base_api_handler import DatamintException
+from datamint.apihandler.api_handler import APIHandler
+from datamint.apihandler.base_api_handler import DatamintException
 from datetime import datetime, timezone
 from typing import List, Dict, Optional, Union, Any, Tuple, IO, Literal
 from collections import defaultdict
-from datamintapi.dataset.dataset import DatamintDataset
+from datamint.dataset.dataset import DatamintDataset
 import os
 import numpy as np
 import heapq
-from datamintapi.utils import io_utils
+from datamint.utils import io_utils
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -570,7 +570,7 @@ class Experiment:
 
         Args:
             split (str): The split of the dataset to get. Can be one of ['all', 'train', 'test', 'val'].
-            **kwargs: Additional arguments to pass to the :py:class:`~datamintapi.dataset.dataset.DatamintDataset` class.
+            **kwargs: Additional arguments to pass to the :py:class:`~datamint.dataset.dataset.DatamintDataset` class.
 
         Returns:
             DatamintDataset: The dataset object.
@@ -815,22 +815,22 @@ class Experiment:
         Example:
             .. code-block:: python
 
-            resource_id = '123'
-            predictions = np.array([[0.1, 0.4], [0.9, 0.2]])
-            label_name = 'fracture'
-            exp.log_segmentation_predictions(resource_id, predictions, label_name, threshold=0.5)
+                resource_id = '123'
+                predictions = np.array([[0.1, 0.4], [0.9, 0.2]])
+                label_name = 'fracture'
+                exp.log_segmentation_predictions(resource_id, predictions, label_name, threshold=0.5)
 
             .. code-block:: python
 
-            resource_id = '456'
-            predictions = np.array([[0, 1, 2], [1, 2, 0]])  # Multi-class mask with values 0, 1, 2
-            label_name = {1: 'Femur', 2: 'Tibia'}  # Mapping of pixel values to class names
-            exp.log_segmentation_predictions(
-                resource_id, 
-                predictions, 
-                label_name, 
-                predictions_format='multi-class'
-            )
+                resource_id = '456'
+                predictions = np.array([[0, 1, 2], [1, 2, 0]])  # Multi-class mask with values 0, 1, 2
+                label_name = {1: 'Femur', 2: 'Tibia'}  # Mapping of pixel values to class names
+                exp.log_segmentation_predictions(
+                    resource_id, 
+                    predictions, 
+                    label_name, 
+                    predictions_format='multi-class'
+                )
         """
 
         if predictions_format not in ['multi-class', 'probability']:

{datamint-1.2.4/datamintapi → datamint-1.4.0/datamint}/logging.yaml

@@ -7,13 +7,13 @@ handlers:
     level: WARNING
     show_time: False
   console_user:
-    class: datamintapi.utils.logging_utils.ConditionalRichHandler
+    class: datamint.utils.logging_utils.ConditionalRichHandler
     level: INFO
     show_path: False
     show_time: False
 
 loggers:
-  datamintapi:
+  datamint:
     level: ERROR
     handlers: [console]
     propagate: no

{datamint-1.2.4/datamintapi → datamint-1.4.0/datamint}/utils/logging_utils.py

@@ -45,7 +45,7 @@ def load_cmdline_logging_config():
             with open('logging_dev.yaml', 'r') as f:
                 config = yaml.safe_load(f)
         except:
-            with importlib.resources.open_text('datamintapi', 'logging.yaml') as f:
+            with importlib.resources.open_text('datamint', 'logging.yaml') as f:
                 config = yaml.safe_load(f.read())
 
         logging.config.dictConfig(config)

{datamint-1.2.4 → datamint-1.4.0}/pyproject.toml

@@ -1,19 +1,19 @@
 [project]
 name = "datamint"
 description = "A library for interacting with the Datamint API, designed for efficient data management, processing and Deep Learning workflows."
-version = "1.2.4"
+version = "1.4.0"
 dynamic = ["dependencies"]
 requires-python = ">=3.10"
 readme = "README.md"
 
 [project.scripts]
-datamint-upload = 'datamintapi.client_cmd_tools.datamint_upload:main'
-datamint-config = 'datamintapi.client_cmd_tools.datamint_config:main'
+datamint-upload = 'datamint.client_cmd_tools.datamint_upload:main'
+datamint-config = 'datamint.client_cmd_tools.datamint_config:main'
 
 [tool.poetry]
 # license = "Proprietary" # https://python-poetry.org/docs/pyproject/
-include = [{ path = "datamintapi/logging.yaml", format = ["sdist", "wheel"] }]
-packages = [ { include = "datamint" }, { include = "datamintapi" }]
+include = [{ path = "datamint/logging.yaml", format = ["sdist", "wheel"] }]
+packages = [ { include = "datamint" }]
 
 # https://python-poetry.org/docs/dependency-specification/
 [tool.poetry.dependencies]
@@ -40,6 +40,8 @@ matplotlib = "*"
 lightning = "*"
 albumentations = ">=2.0.0"
 lazy-loader = ">=0.3.0"
+# For compatibility with the datamintapi package
+datamintapi = "0.0.*"
 # Extra dependencies for docs
 sphinx = { version = ">=5.0", optional = true }
 sphinx_rtd_theme = { version = ">=2.0.0", optional = true }

datamint-1.2.4/datamint/__init__.py

@@ -1,11 +0,0 @@
-"""
-Datamint API package alias.
-
-This module serves as an alias for the datamintapi package.
-"""
-
-from datamintapi import *
-import importlib.metadata
-
-__name__ = "datamint"
-__version__ = importlib.metadata.version(__name__)