datamint 1.3.0__tar.gz → 1.4.1__tar.gz

{datamint-1.3.0 → datamint-1.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: datamint
-Version: 1.3.0
+Version: 1.4.1
 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-1.3.0 → datamint-1.4.1}/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,

{datamint-1.3.0 → datamint-1.4.1}/datamint/apihandler/dto/annotation_dto.py

@@ -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.3.0 → datamint-1.4.1}/datamint/apihandler/root_api_handler.py

@@ -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.3.0 → datamint-1.4.1}/datamint/client_cmd_tools/datamint_upload.py

@@ -256,12 +256,91 @@ 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)
+    
+    # Handle .nii.gz files specially - need to remove both extensions
+    if file_path.name.endswith('.nii.gz'):
+        base_name = file_path.name[:-7]  # Remove .nii.gz
+        json_path = file_path.parent / f"{base_name}.json"
+    else:
+        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 = []
+        
+        for original_file in files_path:
+            if original_file not in used_json_files:
+                original_index = files_path.index(original_file)
+                filtered_metadata_files.append(metadata_files[original_index])
+
+        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 +381,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('--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 +417,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 +434,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 +463,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 +474,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 +501,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 +524,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 +553,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 +561,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 +584,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.3.0 → datamint-1.4.1}/datamint/experiment/experiment.py

@@ -803,7 +803,7 @@ class Experiment:
         Args:
             resource_id: The resource ID of the sample.
             predictions: The predictions of the model. One binary mask for each class. Can be a numpy array of shape (H, W) or (N,H,W);
-                Or a path to a png file; Or a path to a .nii.gz file.
+                Or a path to a png file; Or a path to a .nii/.nii.gz file.
             label_name: The name of the class or a dictionary mapping pixel values to names.
                 Example: ``{1: 'Femur', 2: 'Tibia'}`` means that pixel value 1 is 'Femur' and pixel value 2 is 'Tibia'.
             frame_index: The frame index of the prediction or a list of frame indexes.

{datamint-1.3.0 → datamint-1.4.1}/datamint/utils/io_utils.py

@@ -54,17 +54,32 @@ def read_video(file_path: str, index: int = None) -> np.ndarray:
 
 
 def read_nifti(file_path: str) -> np.ndarray:
-    imgs = nib.load(file_path).get_fdata()  # shape: (W, H, #frame) or (W, H)
-    if imgs.ndim == 2:
-        imgs = imgs.transpose(1, 0)
-        imgs = imgs[np.newaxis, np.newaxis]
-    elif imgs.ndim == 3:
-        imgs = imgs.transpose(2, 1, 0)
-        imgs = imgs[:, np.newaxis]
-    else:
-        raise ValueError(f"Unsupported number of dimensions in '{file_path}': {imgs.ndim}")
+    """
+    Read a NIfTI file and return the image data in standardized format.
+    
+    Args:
+        file_path: Path to the NIfTI file (.nii or .nii.gz)
+        
+    Returns:
+        np.ndarray: Image data with shape (#frames, C, H, W)
+    """
+    try:
+        nii_img = nib.load(file_path)
+        imgs = nii_img.get_fdata()  # shape: (W, H, #frame) or (W, H)
+        
+        if imgs.ndim == 2:
+            imgs = imgs.transpose(1, 0)  # (W, H) -> (H, W)
+            imgs = imgs[np.newaxis, np.newaxis]  # -> (1, 1, H, W)
+        elif imgs.ndim == 3:
+            imgs = imgs.transpose(2, 1, 0)  # (W, H, #frame) -> (#frame, H, W)
+            imgs = imgs[:, np.newaxis]  # -> (#frame, 1, H, W)
+        else:
+            raise ValueError(f"Unsupported number of dimensions in '{file_path}': {imgs.ndim}")
 
-    return imgs
+        return imgs
+    except Exception as e:
+        _LOGGER.error(f"Failed to read NIfTI file '{file_path}': {e}")
+        raise e
 
 
 def read_image(file_path: str) -> np.ndarray:
@@ -123,6 +138,18 @@ def read_array_normalized(file_path: str,
             else:
                 if mime_type == 'image/x.nifti' or file_path.endswith(NII_EXTS):
                     imgs = read_nifti(file_path)
+                    # For NIfTI files, try to load associated JSON metadata
+                    if return_metainfo:
+                        json_path = file_path.replace('.nii.gz', '.json').replace('.nii', '.json')
+                        if os.path.exists(json_path):
+                            try:
+                                import json
+                                with open(json_path, 'r') as f:
+                                    metainfo = json.load(f)
+                                _LOGGER.debug(f"Loaded JSON metadata from {json_path}")
+                            except Exception as e:
+                                _LOGGER.warning(f"Failed to load JSON metadata from {json_path}: {e}")
+                                metainfo = None
                 elif mime_type.startswith('image/') or file_path.endswith(IMAGE_EXTS):
                     imgs = read_image(file_path)
                 elif file_path.endswith('.npy') or mime_type == 'application/x-numpy-data':

{datamint-1.3.0 → datamint-1.4.1}/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 = "1.3.0"
+version = "1.4.1"
 dynamic = ["dependencies"]
 requires-python = ">=3.10"
 readme = "README.md"