datamint 1.9.1__tar.gz → 1.9.3__tar.gz

{datamint-1.9.1 → datamint-1.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: datamint
-Version: 1.9.1
+Version: 1.9.3
 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
@@ -19,7 +19,7 @@ Requires-Dist: humanize (>=4.0.0,<5.0.0)
 Requires-Dist: lazy-loader (>=0.3.0)
 Requires-Dist: lightning
 Requires-Dist: matplotlib
-Requires-Dist: medimgkit (>=0.4.4)
+Requires-Dist: medimgkit (>=0.5.0)
 Requires-Dist: nest-asyncio (>=1.0.0,<2.0.0)
 Requires-Dist: nibabel (>=4.0.0)
 Requires-Dist: numpy

{datamint-1.9.1 → datamint-1.9.3}/datamint/apihandler/annotation_api_handler.py

@@ -995,11 +995,11 @@ class AnnotationAPIHandler(BaseAPIHandler):
 
     def update_annotation_worklist(self,
                                    worklist_id: str,
-                                   frame_labels: list[str] = None,
-                                   image_labels: list[str] = None,
-                                   annotations: list[dict] = None,
-                                   status: Literal['new', 'updating', 'active', 'completed'] = None,
-                                   name: str = None,
+                                   frame_labels: list[str] | None = None,
+                                   image_labels: list[str] | None = None,
+                                   annotations: list[dict] | None = None,
+                                   status: Literal['new', 'updating', 'active', 'completed'] | None = None,
+                                   name: str | None = None,
                                    ):
         """
         Update the status of an annotation worklist.

{datamint-1.9.1 → datamint-1.9.3}/datamint/apihandler/base_api_handler.py

@@ -1,4 +1,4 @@
-from typing import Optional, Literal, Generator, TypeAlias, Dict, Union, List
+from typing import Optional, Literal, Generator, TypeAlias
 import pydicom.dataset
 from requests import Session
 from requests.exceptions import HTTPError
@@ -15,6 +15,7 @@ import nibabel as nib
 from nibabel.filebasedimages import FileBasedImage as nib_FileBasedImage
 from datamint import configs
 import gzip
+from datamint.exceptions import DatamintException
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -29,13 +30,6 @@ ResourceFields: TypeAlias = Literal['modality', 'created_by', 'published_by', 'p
 _PAGE_LIMIT = 5000
 
 
-class DatamintException(Exception):
-    """
-    Base class for exceptions in this module.
-    """
-    pass
-
-
 class ResourceNotFoundError(DatamintException):
     """
     Exception raised when a resource is not found. 
@@ -196,10 +190,10 @@ class BaseAPIHandler:
                 _LOGGER.error(f"Error in request to {request_args['url']}: {e}")
             if status_code >= 400 and status_code < 500:
                 try:
-                    _LOGGER.error(f"Error response: {response.text}")
+                    _LOGGER.info(f"Error response: {response.text}")
                     error_data = response.json()
                 except Exception as e2:
-                    _LOGGER.error(f"Error parsing the response. {e2}")
+                    _LOGGER.info(f"Error parsing the response. {e2}")
                 else:
                     if isinstance(error_data['message'], str) and ' not found' in error_data['message'].lower():
                         # Will be caught by the caller and properly initialized:

{datamint-1.9.1 → datamint-1.9.3}/datamint/apihandler/root_api_handler.py

@@ -6,7 +6,7 @@ from requests.exceptions import HTTPError
 import logging
 import asyncio
 import aiohttp
-from medimgkit.dicom_utils import anonymize_dicom, to_bytesio, is_dicom, is_dicom_report
+from medimgkit.dicom_utils import anonymize_dicom, to_bytesio, is_dicom, is_dicom_report, GeneratorWithLength
 from medimgkit import dicom_utils, standardize_mimetype
 from medimgkit.io_utils import is_io_object, peek
 from medimgkit.format_detection import guess_typez, guess_extension, DEFAULT_MIME_TYPE
@@ -185,9 +185,7 @@ class RootAPIHandler(BaseAPIHandler):
             resp_data = await self._run_request_async(request_params, session)
             if 'error' in resp_data:
                 raise DatamintException(resp_data['error'])
-            _LOGGER.info(f"Response on uploading {name}: {resp_data}")
-
-            _USER_LOGGER.info(f'"{name}" uploaded')
+            _LOGGER.debug(f"Response on uploading {name}: {resp_data}")
             return resp_data['id']
         except Exception as e:
             if 'name' in locals():
@@ -212,6 +210,7 @@ class RootAPIHandler(BaseAPIHandler):
                                       segmentation_files: Optional[list[dict]] = None,
                                       transpose_segmentation: bool = False,
                                       metadata_files: Optional[list[str | dict | None]] = None,
+                                      progress_bar: tqdm | None = None,
                                       ) -> list[str]:
         if on_error not in ['raise', 'skip']:
             raise ValueError("on_error must be either 'raise' or 'skip'")
@@ -223,7 +222,10 @@ class RootAPIHandler(BaseAPIHandler):
             metadata_files = _infinite_gen(None)
 
         async with aiohttp.ClientSession() as session:
-            async def __upload_single_resource(file_path, segfiles: dict[str, list | dict], metadata_file: str | dict | None):
+            async def __upload_single_resource(file_path, segfiles: dict[str, list | dict],
+                                               metadata_file: str | dict | None):
+                name = file_path.name if is_io_object(file_path) else file_path
+                name = os.path.basename(name)
                 rid = await self._upload_single_resource_async(
                     file_path=file_path,
                     mimetype=mimetype,
@@ -237,6 +239,12 @@ class RootAPIHandler(BaseAPIHandler):
                     publish=publish,
                     metadata_file=metadata_file,
                 )
+                if progress_bar:
+                    progress_bar.update(1)
+                    progress_bar.set_postfix(file=name)
+                else:
+                    _USER_LOGGER.info(f'"{name}" uploaded')
+
                 if segfiles is not None:
                     fpaths = segfiles['files']
                     names = segfiles.get('names', _infinite_gen(None))
@@ -258,30 +266,55 @@ class RootAPIHandler(BaseAPIHandler):
                      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]:
+    def _assemble_dicoms(self, files_path: Sequence[str | IO]
+                         ) -> tuple[Sequence[str | IO], bool, Sequence[int]]:
+        """
+        Assembles DICOM files into a single file.
+
+        Args:
+            files_path: The paths to the DICOM files to assemble.
+
+        Returns:
+            A tuple containing:
+                - The paths to the assembled DICOM files.
+                - A boolean indicating whether the assembly was successful.
+                - same length as the output assembled DICOMs, mapping assembled DICOM to original DICOMs.
+        """
         dicoms_files_path = []
         other_files_path = []
-        for f in files_path:
+        dicom_original_idxs = []
+        others_original_idxs = []
+        for i, f in enumerate(files_path):
             if is_dicom(f):
                 dicoms_files_path.append(f)
+                dicom_original_idxs.append(i)
             else:
                 other_files_path.append(f)
+                others_original_idxs.append(i)
 
         orig_len = len(dicoms_files_path)
         if orig_len == 0:
             _LOGGER.debug("No DICOM files found to assemble.")
-            return files_path, False
+            return files_path, False, []
         dicoms_files_path = dicom_utils.assemble_dicoms(dicoms_files_path, return_as_IO=True)
 
         new_len = len(dicoms_files_path)
         if new_len != orig_len:
             _LOGGER.info(f"Assembled {new_len} dicom files out of {orig_len} files.")
-            files_path = itertools.chain(dicoms_files_path, other_files_path)
+            mapping_idx = [None] * len(files_path)
+            
+            files_path = GeneratorWithLength(itertools.chain(dicoms_files_path, other_files_path), 
+                                             length=new_len + len(other_files_path))
             assembled = True
+            for orig_idx, value in zip(dicom_original_idxs, dicoms_files_path.inverse_mapping_idx):
+                mapping_idx[orig_idx] = value
+            for i, orig_idx in enumerate(others_original_idxs):
+                mapping_idx[orig_idx] = new_len + i
         else:
             assembled = False
+            mapping_idx = [i for i in range(len(files_path))]
 
-        return files_path, assembled
+        return files_path, assembled, mapping_idx
 
     def upload_resource(self,
                         file_path: str | IO | pydicom.dataset.Dataset,
@@ -364,7 +397,8 @@ class RootAPIHandler(BaseAPIHandler):
             transpose_segmentation=transpose_segmentation,
             modality=modality,
             assemble_dicoms=assemble_dicoms,
-            metadata=metadata
+            metadata=metadata,
+            progress_bar=False
         )
 
         return result[0]
@@ -385,7 +419,8 @@ class RootAPIHandler(BaseAPIHandler):
                          modality: Optional[str] = None,
                          assemble_dicoms: bool = True,
                          metadata: list[str | dict | None] | dict | str | None = None,
-                         discard_dicom_reports: bool = True
+                         discard_dicom_reports: bool = True,
+                         progress_bar: bool = False
                          ) -> list[str | Exception] | str | Exception:
         """
         Upload resources.
@@ -433,17 +468,17 @@ class RootAPIHandler(BaseAPIHandler):
             # Create filtered lists maintaining index correspondence
             filtered_files = []
             filtered_metadata = []
-            
+
             for i, f in enumerate(files_path):
                 if not is_dicom_report(f):
                     filtered_files.append(f)
                     if metadata is not None:
                         filtered_metadata.append(metadata[i])
-            
+
             files_path = filtered_files
             if metadata is not None:
                 metadata = filtered_metadata
-                
+
             if old_size is not None and old_size != len(files_path):
                 _LOGGER.info(f"Discarded {old_size - len(files_path)} DICOM report files from upload.")
 
@@ -454,9 +489,16 @@ class RootAPIHandler(BaseAPIHandler):
         if metadata is not None and len(metadata) != len(files_path):
             raise ValueError("The number of metadata files must match the number of resources.")
         if assemble_dicoms:
-            files_path, assembled = self._assemble_dicoms(files_path)
+            files_path, assembled, mapping_idx = self._assemble_dicoms(files_path)
             assemble_dicoms = assembled
-        
+        else:
+            mapping_idx = [i for i in range(len(files_path))]
+        n_files = len(files_path)
+
+        if n_files <= 1:
+            # Disable progress bar for single file uploads
+            progress_bar = False
+
         if segmentation_files is not None:
             if assemble_dicoms:
                 raise NotImplementedError("Segmentation files cannot be uploaded when assembling dicoms yet.")
@@ -484,22 +526,32 @@ class RootAPIHandler(BaseAPIHandler):
                             "segmentation_files['names'] must have the same length as segmentation_files['files'].")
 
         loop = asyncio.get_event_loop()
-        task = self._upload_resources_async(files_path=files_path,
-                                            mimetype=mimetype,
-                                            anonymize=anonymize,
-                                            anonymize_retain_codes=anonymize_retain_codes,
-                                            on_error=on_error,
-                                            tags=tags,
-                                            mung_filename=mung_filename,
-                                            channel=channel,
-                                            publish=publish,
-                                            segmentation_files=segmentation_files,
-                                            transpose_segmentation=transpose_segmentation,
-                                            modality=modality,
-                                            metadata_files=metadata,
-                                            )
-
-        resource_ids = loop.run_until_complete(task)
+        pbar = None
+        try:
+            if progress_bar:
+                pbar = tqdm(total=n_files, desc="Uploading resources", unit="file")
+
+            task = self._upload_resources_async(files_path=files_path,
+                                                mimetype=mimetype,
+                                                anonymize=anonymize,
+                                                anonymize_retain_codes=anonymize_retain_codes,
+                                                on_error=on_error,
+                                                tags=tags,
+                                                mung_filename=mung_filename,
+                                                channel=channel,
+                                                publish=publish,
+                                                segmentation_files=segmentation_files,
+                                                transpose_segmentation=transpose_segmentation,
+                                                modality=modality,
+                                                metadata_files=metadata,
+                                                progress_bar=pbar
+                                                )
+
+            resource_ids = loop.run_until_complete(task)
+        finally:
+            if pbar:
+                pbar.close()
+        
         _LOGGER.info(f"Resources uploaded: {resource_ids}")
 
         if publish_to is not None:
@@ -512,6 +564,10 @@ class RootAPIHandler(BaseAPIHandler):
                 if on_error == 'raise':
                     raise e
 
+        if mapping_idx:
+            _LOGGER.debug(f"Mapping indices for DICOM files: {mapping_idx}")
+            resource_ids = [resource_ids[idx] for idx in mapping_idx]
+
         if is_multiple_resources:
             return resource_ids
         return resource_ids[0]
@@ -590,7 +646,9 @@ class RootAPIHandler(BaseAPIHandler):
         # get the project id by its name
         project = self.get_project_by_name(project_name)
         if 'error' in project:
-            raise ResourceNotFoundError('project', {'project_name': project_name})
+            project = self.get_project_by_id(project_name)
+            if 'error' in project:
+                raise ResourceNotFoundError('project', {'project_name': project_name})
 
         dataset_id = project['dataset_id']
 
@@ -652,7 +710,8 @@ class RootAPIHandler(BaseAPIHandler):
             raise e
 
     @staticmethod
-    def __process_files_parameter(file_path: str | IO | Sequence[str | IO] | pydicom.dataset.Dataset) -> tuple[Sequence[str | IO], bool]:
+    def __process_files_parameter(file_path: str | IO | Sequence[str | IO] | pydicom.dataset.Dataset
+                                  ) -> tuple[Sequence[str | IO], bool]:
         """
         Process the file_path parameter to ensure it is a list of file paths or IO objects.
         """
@@ -1123,11 +1182,10 @@ class RootAPIHandler(BaseAPIHandler):
 
         loop = asyncio.get_event_loop()
         loop.run_until_complete(_delete_all_resources_async())
-            
-    
+
     async def _delete_resource_async(self,
-                                   resource_id: str,
-                                   session: aiohttp.ClientSession | None = None) -> None:
+                                     resource_id: str,
+                                     session: aiohttp.ClientSession | None = None) -> None:
         """
         Asynchronously delete a resource by its unique id.
 

{datamint-1.9.1 → datamint-1.9.3}/datamint/client_cmd_tools/datamint_config.py

@@ -1,46 +1,13 @@
 import argparse
 import logging
-import os
-import platform
 from datamint import configs
-from datamint.utils.logging_utils import load_cmdline_logging_config
+from datamint.utils.logging_utils import load_cmdline_logging_config, ConsoleWrapperHandler
 from rich.prompt import Prompt, Confirm
 from rich.console import Console
-from rich.theme import Theme
-
-# Create a custom theme that works well on both dark and blue backgrounds
-def _create_console_theme() -> Theme:
-    """Create a custom Rich theme optimized for cross-platform terminals."""
-    # Detect if we're likely on PowerShell (Windows + PowerShell)
-    is_powershell = (
-        platform.system() == "Windows" and 
-        os.environ.get("PSModulePath") is not None
-    )
-    
-    if is_powershell:
-        # PowerShell blue background - use high contrast colors
-        return Theme({
-            "warning": "bright_yellow",
-            "error": "bright_red on white",
-            "success": "bright_green",
-            "key": "bright_cyan",
-            "accent": "bright_cyan",
-            "title": "bold"
-        })
-    else:
-        # Linux/Unix terminals - standard colors
-        return Theme({
-            "warning": "yellow",
-            "error": "red",
-            "success": "green",
-            "key": "cyan",
-            "accent": "bright_blue",
-            "title": "bold"
-        })
-
-# Create console with custom theme
-console = Console(theme=_create_console_theme())
+
 _LOGGER = logging.getLogger(__name__)
+_USER_LOGGER = logging.getLogger('user_logger')
+console: Console
 
 
 def configure_default_url():
@@ -125,7 +92,7 @@ def test_connection():
         projects = api.get_projects()
         console.print(f"[success]✅ Connection successful! Found {len(projects)} projects.[/success]")
     except ImportError:
-        console.print("[error]❌ Full API not available. Install with: pip install datamint-python-api[full][/error]")
+        console.print("[error]❌ Full API not available. Install with: pip install datamint[/error]")
     except Exception as e:
         console.print(f"[error]❌ Connection failed: {e}[/error]")
 
@@ -170,7 +137,9 @@ def interactive_mode():
 
 def main():
     """Main entry point for the configuration tool."""
+    global console
     load_cmdline_logging_config()
+    console = [h for h in _USER_LOGGER.handlers if isinstance(h, ConsoleWrapperHandler)][0].console
     parser = argparse.ArgumentParser(
         description='🔧 Datamint API Configuration Tool',
         epilog="""

{datamint-1.9.1 → datamint-1.9.3}/datamint/client_cmd_tools/datamint_upload.py

@@ -1,3 +1,4 @@
+from datamint.exceptions import DatamintException
 import argparse
 from datamint.apihandler.api_handler import APIHandler
 import os
@@ -11,18 +12,87 @@ from typing import Generator, Optional, Any
 from collections import defaultdict
 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
+from datamint.utils.logging_utils import load_cmdline_logging_config, ConsoleWrapperHandler
+from rich.console import Console
 import yaml
 from collections.abc import Iterable
 import pandas as pd
+import pydicom.errors
 
 # Create two loggings: one for the user and one for the developer
 _LOGGER = logging.getLogger(__name__)
 _USER_LOGGER = logging.getLogger('user_logger')
+logging.getLogger('pydicom').setLevel(logging.ERROR)
+CONSOLE: Console
 
 MAX_RECURSION_LIMIT = 1000
 
+# Default extensions to exclude when --include-extensions is not specified
+DEFAULT_EXCLUDED_EXTENSIONS = [
+    '.txt', '.json', '.xml', '.docx', '.doc', '.pdf', '.xlsx', '.xls', '.csv', '.tsv',
+    '.log', '.ini', '.cfg', '.conf', '.yaml', '.yml', '.md', '.rst', '.html', '.htm',
+    '.exe', '.bat', '.sh', '.py', '.js', '.css',
+    '.sql', '.bak', '.tmp', '.temp', '.lock', '.DS_Store', '.gitignore'
+]
+
+
+def _get_minimal_distinguishing_paths(file_paths: list[str]) -> dict[str, str]:
+    """
+    Generate minimal distinguishing paths for files to avoid ambiguity when multiple files have the same name.
+
+    Args:
+        file_paths: List of file paths
+
+    Returns:
+        Dictionary mapping full path to minimal distinguishing path
+    """
+    if not file_paths:
+        return {}
+
+    # Convert to Path objects and get absolute paths
+    paths = [Path(fp).resolve() for fp in file_paths]
+    result = {}
+
+    # Group files by basename
+    basename_groups = defaultdict(list)
+    for i, path in enumerate(paths):
+        basename_groups[path.name].append((i, path))
+
+    for basename, path_list in basename_groups.items():
+        if len(path_list) == 1:
+            # Only one file with this name, use just the basename
+            idx, path = path_list[0]
+            result[file_paths[idx]] = basename
+        else:
+            # Multiple files with same name, need to distinguish them
+            path_parts_list = [path.parts for _, path in path_list]
+
+            # Find the minimum number of parent directories needed to distinguish
+            max_depth_needed = 1
+            for depth in range(1, max(len(parts) for parts in path_parts_list) + 1):
+                # Check if this depth is enough to distinguish all files
+                suffixes = []
+                for parts in path_parts_list:
+                    if depth >= len(parts):
+                        suffixes.append('/'.join(parts))
+                    else:
+                        suffixes.append('/'.join(parts[-depth:]))
+
+                if len(set(suffixes)) == len(suffixes):
+                    # All suffixes are unique at this depth
+                    max_depth_needed = depth
+                    break
+
+            # Apply the minimal distinguishing paths
+            for (idx, path), parts in zip(path_list, path_parts_list):
+                if max_depth_needed >= len(parts):
+                    distinguishing_path = '/'.join(parts)
+                else:
+                    distinguishing_path = '/'.join(parts[-max_depth_needed:])
+                result[file_paths[idx]] = distinguishing_path
+
+    return result
+
 
 def _read_segmentation_names(segmentation_names_path: str | Path) -> dict:
     """
@@ -124,7 +194,7 @@ def walk_to_depth(path: str | Path,
                   depth: int,
                   exclude_pattern: str | None = None) -> Generator[Path, None, None]:
     path = Path(path)
-    
+
     # Check for DICOMDIR first at current directory level
     dicomdir_path = detect_dicomdir(path)
     if dicomdir_path is not None:
@@ -138,7 +208,7 @@ def walk_to_depth(path: str | Path,
         except Exception as e:
             _USER_LOGGER.warning(f"Failed to parse DICOMDIR at {path}: {e}. Falling back to directory scan.")
             # Continue with regular directory scanning below
-    
+
     # Regular directory scanning
     for child in path.iterdir():
         if _is_system_file(child):
@@ -195,6 +265,7 @@ def handle_api_key() -> str | None:
     If it does not exist, it asks the user to input it.
     Then, it asks the user if he wants to save the API key at a proper location in the machine
     """
+    from datamint.client_cmd_tools.datamint_config import ask_api_key
     api_key = configs.get_value(configs.APIKEY_KEY)
     if api_key is None:
         _USER_LOGGER.info("API key not found. Please provide it:")
@@ -462,6 +533,8 @@ def _parse_args() -> tuple[Any, list[str], Optional[list[dict]], Optional[list[s
     parser.add_argument('--channel', '--name', type=str, required=False,
                         help='Channel name (arbritary) to upload the resources to. \
                             Useful for organizing the resources in the platform.')
+    parser.add_argument('--project', type=str, required=False,
+                        help='Project name to add the uploaded resources to after successful upload.')
     parser.add_argument('--retain-pii', action='store_true', help='Do not anonymize DICOMs')
     parser.add_argument('--retain-attribute', type=_tuple_int_type, action='append',
                         default=[],
@@ -479,7 +552,8 @@ def _parse_args() -> tuple[Any, list[str], Optional[list[dict]], Optional[list[s
                         help='File extensions to be considered for uploading. Default: all file extensions.' +
                         ' Example: --include-extensions dcm jpg png')
     parser.add_argument('--exclude-extensions', type=str, nargs='+',
-                        help='File extensions to be excluded from uploading. Default: none.' +
+                        help='File extensions to be excluded from uploading. ' +
+                        'Default: common non-medical file extensions (.txt, .json, .xml, .docx, etc.) when --include-extensions is not specified.' +
                         ' Example: --exclude-extensions txt csv'
                         )
     parser.add_argument('--segmentation_path', type=_is_valid_path_argparse, metavar="FILE",
@@ -519,7 +593,6 @@ def _parse_args() -> tuple[Any, list[str], Optional[list[dict]], Optional[list[s
 
     if args.verbose:
         # Get the console handler and set to debug
-        print(logging.getLogger().handlers)
         logging.getLogger().handlers[0].setLevel(logging.DEBUG)
         logging.getLogger('datamint').setLevel(logging.DEBUG)
         _LOGGER.setLevel(logging.DEBUG)
@@ -532,6 +605,11 @@ def _parse_args() -> tuple[Any, list[str], Optional[list[dict]], Optional[list[s
     if args.include_extensions is not None and args.exclude_extensions is not None:
         raise ValueError("--include-extensions and --exclude-extensions are mutually exclusive.")
 
+    # Apply default excluded extensions if neither include nor exclude extensions are specified
+    if args.include_extensions is None and args.exclude_extensions is None:
+        args.exclude_extensions = DEFAULT_EXCLUDED_EXTENSIONS
+        _LOGGER.debug(f"Applied default excluded extensions: {args.exclude_extensions}")
+
     try:
         if os.path.isfile(args.path):
             file_path = [args.path]
@@ -606,12 +684,15 @@ def print_input_summary(files_path: list[str],
     ext_counts = [(ext, count) for ext, count in ext_dict.items()]
     ext_counts.sort(key=lambda x: x[1], reverse=True)
 
+    # Get distinguishing paths for better display
+    distinguishing_paths = _get_minimal_distinguishing_paths(files_path)
+
     _USER_LOGGER.info(f"Number of files to be uploaded: {total_files}")
-    _USER_LOGGER.info(f"\t{files_path[0]}")
+    _USER_LOGGER.info(f"\t{distinguishing_paths[files_path[0]]}")
     if total_files >= 2:
         if total_files >= 3:
             _USER_LOGGER.info("\t(...)")
-        _USER_LOGGER.info(f"\t{files_path[-1]}")
+        _USER_LOGGER.info(f"\t{distinguishing_paths[files_path[-1]]}")
     _USER_LOGGER.info(f"Total size of the upload: {naturalsize(total_size)}")
     _USER_LOGGER.info(f"Number of files per extension:")
     for ext, count in ext_counts:
@@ -653,22 +734,28 @@ def print_results_summary(files_path: list[str],
                           results: list[str | Exception]) -> int:
     # Check for failed uploads
     failure_files = [f for f, r in zip(files_path, results) if isinstance(r, Exception)]
+    # Get distinguishing paths for better error reporting
+    distinguishing_paths = _get_minimal_distinguishing_paths(files_path)
+
     _USER_LOGGER.info(f"\nUpload summary:")
     _USER_LOGGER.info(f"\tTotal files: {len(files_path)}")
     _USER_LOGGER.info(f"\tSuccessful uploads: {len(files_path) - len(failure_files)}")
-    _USER_LOGGER.info(f"\tFailed uploads: {len(failure_files)}")
     if len(failure_files) > 0:
-        _USER_LOGGER.warning(f"\tFailed files: {[os.path.basename(f) for f in failure_files]}")
+        _USER_LOGGER.warning(f"\tFailed uploads: {len(failure_files)}")
+        _USER_LOGGER.warning(f"\tFailed files: {[distinguishing_paths[f] for f in failure_files]}")
         _USER_LOGGER.warning(f"\nFailures:")
         for f, r in zip(files_path, results):
-            _LOGGER.debug(f"Failure: {f} - {r}")
             if isinstance(r, Exception):
-                _USER_LOGGER.warning(f"\t{os.path.basename(f)}: {r}")
+                _USER_LOGGER.warning(f"\t{distinguishing_paths[f]}: {r}")
+    else:
+        CONSOLE.print(f'✅ All uploads successful!', style='success')
     return len(failure_files)
 
 
 def main():
+    global CONSOLE
     load_cmdline_logging_config()
+    CONSOLE = [h for h in _USER_LOGGER.handlers if isinstance(h, ConsoleWrapperHandler)][0].console
 
     try:
         args, files_path, segfiles, metadata_files = _parse_args()
@@ -676,40 +763,67 @@ def main():
         _USER_LOGGER.error(f'Error validating arguments. {e}')
         sys.exit(1)
 
-    print_input_summary(files_path,
-                        args=args,
-                        segfiles=segfiles,
-                        metadata_files=metadata_files,
-                        include_extensions=args.include_extensions)
+    try:
+        print_input_summary(files_path,
+                            args=args,
+                            segfiles=segfiles,
+                            metadata_files=metadata_files,
+                            include_extensions=args.include_extensions)
+
+        if not args.yes:
+            confirmation = input("Do you want to proceed with the upload? (y/n): ")
+            if confirmation.lower() != "y":
+                _USER_LOGGER.info("Upload cancelled.")
+                return
+        #######################################
 
-    if not args.yes:
-        confirmation = input("Do you want to proceed with the upload? (y/n): ")
-        if confirmation.lower() != "y":
-            _USER_LOGGER.info("Upload cancelled.")
+        has_a_dicom_file = any(is_dicom(f) for f in files_path)
+
+        try:
+            api_handler = APIHandler(check_connection=True)
+        except DatamintException as e:
+            _USER_LOGGER.error(f'❌ Connection failed: {e}')
+            return
+        try:
+            results = api_handler.upload_resources(channel=args.channel,
+                                                   files_path=files_path,
+                                                   tags=args.tag,
+                                                   on_error='skip',
+                                                   anonymize=args.retain_pii == False and has_a_dicom_file,
+                                                   anonymize_retain_codes=args.retain_attribute,
+                                                   mung_filename=args.mungfilename,
+                                                   publish=args.publish,
+                                                   segmentation_files=segfiles,
+                                                   transpose_segmentation=args.transpose_segmentation,
+                                                   assemble_dicoms=True,
+                                                   metadata=metadata_files,
+                                                   progress_bar=True
+                                                   )
+        except pydicom.errors.InvalidDicomError as e:
+            _USER_LOGGER.error(f'❌ Invalid DICOM file: {e}')
             return
-    #######################################
-
-    has_a_dicom_file = any(is_dicom(f) for f in files_path)
-
-    api_handler = APIHandler()
-    results = api_handler.upload_resources(channel=args.channel,
-                                           files_path=files_path,
-                                           tags=args.tag,
-                                           on_error='skip',
-                                           anonymize=args.retain_pii == False and has_a_dicom_file,
-                                           anonymize_retain_codes=args.retain_attribute,
-                                           mung_filename=args.mungfilename,
-                                           publish=args.publish,
-                                           segmentation_files=segfiles,
-                                           transpose_segmentation=args.transpose_segmentation,
-                                           assemble_dicoms=True,
-                                           metadata=metadata_files
-                                           )
-    _USER_LOGGER.info('Upload finished!')
-    _LOGGER.debug(f"Number of results: {len(results)}")
-
-    num_failures = print_results_summary(files_path, results)
-    if num_failures > 0:
+        _USER_LOGGER.info('Upload finished!')
+        _LOGGER.debug(f"Number of results: {len(results)}")
+
+        # Add resources to project if specified
+        if args.project is not None:
+            _USER_LOGGER.info(f"Adding uploaded resources to project '{args.project}'...")
+            try:
+                # Filter successful uploads to get resource IDs
+                successful_resource_ids = [r for r in results if not isinstance(r, Exception)]
+                if successful_resource_ids:
+                    api_handler.add_to_project(project_name=args.project, resource_ids=successful_resource_ids)
+                    _USER_LOGGER.info(f"✅ Successfully added {len(successful_resource_ids)} resources to project '{args.project}'")
+                else:
+                    _USER_LOGGER.warning("No successful uploads to add to project")
+            except Exception as e:
+                _USER_LOGGER.error(f"❌ Failed to add resources to project '{args.project}': {e}")
+
+        num_failures = print_results_summary(files_path, results)
+        if num_failures > 0:
+            sys.exit(1)
+    except KeyboardInterrupt:
+        CONSOLE.print("\nUpload cancelled by user.", style='warning')
         sys.exit(1)
 
 

datamint-1.9.3/datamint/exceptions.py

@@ -0,0 +1,5 @@
+class DatamintException(Exception):
+    """
+    Base class for exceptions in this module.
+    """
+    pass

{datamint-1.9.1 → datamint-1.9.3}/datamint/logging.yaml

@@ -7,7 +7,7 @@ handlers:
     level: WARNING
     show_time: False
   console_user:
-    class: datamint.utils.logging_utils.ConditionalRichHandler
+    class: datamint.utils.logging_utils.ConsoleWrapperHandler
     level: INFO
     show_path: False
     show_time: False

datamint-1.9.3/datamint/utils/logging_utils.py

@@ -0,0 +1,130 @@
+from rich.theme import Theme
+from logging import Logger, DEBUG, INFO, WARNING, ERROR, CRITICAL
+from rich.console import Console
+import platform
+import os
+import logging
+import logging.config
+from rich.console import ConsoleRenderable
+from rich.logging import RichHandler
+from rich.traceback import Traceback
+import yaml
+import importlib
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class ConditionalRichHandler(RichHandler):
+    """
+    Class that uses 'show_level=True' only if the message level is WARNING or higher.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def handle(self, record):
+        if record.levelno >= logging.WARNING:
+            self.show_level = True
+        else:
+            self.show_level = False
+        super().handle(record)
+
+    def render(self, *, record: logging.LogRecord,
+               traceback: Traceback | None,
+               message_renderable: ConsoleRenderable) -> ConsoleRenderable:
+        # if level is WARNING or higher, add the level column
+        try:
+            self._log_render.show_level = record.levelno >= logging.WARNING
+            ret = super().render(record=record, traceback=traceback, message_renderable=message_renderable)
+            self._log_render.show_level = False
+        except Exception as e:
+            _LOGGER.error(f"Error rendering log. {e}")
+        return ret
+
+
+def load_cmdline_logging_config():
+    # Load the logging configuration file
+    try:
+        try:
+            # try loading the developer's logging config
+            with open('logging_dev.yaml', 'r') as f:
+                config = yaml.safe_load(f)
+        except:
+            with importlib.resources.open_text('datamint', 'logging.yaml') as f:
+                config = yaml.safe_load(f.read())
+
+        logging.config.dictConfig(config)
+    except Exception as e:
+        print(f"Warning: Error loading logging configuration file: {e}")
+        _LOGGER.exception(e)
+        logging.basicConfig(level=logging.INFO)
+
+
+LEVELS_MAPPING = {
+    DEBUG: None,
+    INFO: None,
+    WARNING: "warning",
+    ERROR: "error",
+    CRITICAL: "error"
+}
+
+
+def _create_console_theme() -> Theme:
+    """Create a custom Rich theme optimized for cross-platform terminals."""
+    # Detect if we're likely on PowerShell (Windows + PowerShell)
+    is_powershell = (
+        platform.system() == "Windows" and
+        os.environ.get("PSModulePath") is not None
+    )
+
+    if is_powershell:
+        # PowerShell blue background - use high contrast colors
+        return Theme({
+            "warning": "bright_yellow",
+            "error": "bright_red on white",
+            "success": "bright_green",
+            "key": "bright_cyan",
+            "accent": "bright_cyan",
+            "title": "bold"
+        })
+    else:
+        # Linux/Unix terminals - standard colors
+        return Theme({
+            "warning": "yellow",
+            "error": "red",
+            "success": "green",
+            "key": "cyan",
+            "accent": "bright_blue",
+            "title": "bold"
+        })
+
+
+class ConsoleWrapperHandler(ConditionalRichHandler):
+    """
+    A logging handler that uses a rich.console.Console to print log messages.
+    """
+    def __init__(self, *args, console: Console | None = None, **kwargs):
+        """
+        Initializes the ConsoleWrapperHandler.
+
+        Args:
+            console (Console | None): A rich Console instance. If None, a new one is created.
+        """
+        super().__init__(*args, **kwargs)
+        if console is None:
+            console = Console(theme=_create_console_theme())
+        self.console = console
+
+    def emit(self, record: logging.LogRecord) -> None:
+        """
+        Emits a log record.
+
+        Args:
+            record (logging.LogRecord): The log record to emit.
+        """
+        try:
+            msg = self.format(record)
+            style = LEVELS_MAPPING.get(record.levelno)
+            self.console.print(msg, style=style)
+        except Exception:
+            self.handleError(record)

{datamint-1.9.1 → datamint-1.9.3}/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.9.1"
+version = "1.9.3"
 dynamic = ["dependencies"]
 requires-python = ">=3.10"
 readme = "README.md"
@@ -40,7 +40,7 @@ matplotlib = "*"
 lightning = "*"
 albumentations = ">=2.0.0"
 lazy-loader = ">=0.3.0"
-medimgkit = ">=0.4.4"
+medimgkit = ">=0.5.0"
 # For compatibility with the datamintapi package
 datamintapi = "0.0.*"
 # Extra dependencies for docs

datamint-1.9.1/datamint/utils/logging_utils.py

@@ -1,55 +0,0 @@
-import logging
-import logging.config
-from rich.console import ConsoleRenderable
-from rich.logging import RichHandler
-from rich.traceback import Traceback
-import yaml
-import importlib
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class ConditionalRichHandler(RichHandler):
-    """
-    Class that uses 'show_level=True' only if the message level is WARNING or higher.
-    """
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-    def handle(self, record):
-        if record.levelno >= logging.WARNING:
-            self.show_level = True
-        else:
-            self.show_level = False
-        super().handle(record)
-
-    def render(self, *, record: logging.LogRecord,
-               traceback: Traceback | None,
-               message_renderable: ConsoleRenderable) -> ConsoleRenderable:
-        # if level is WARNING or higher, add the level column
-        try:
-            self._log_render.show_level = record.levelno >= logging.WARNING
-            ret = super().render(record=record, traceback=traceback, message_renderable=message_renderable)
-            self._log_render.show_level = False
-        except Exception as e:
-            _LOGGER.error(f"Error rendering log. {e}")
-        return ret
-
-
-def load_cmdline_logging_config():
-    # Load the logging configuration file
-    try:
-        try:
-            # try loading the developer's logging config
-            with open('logging_dev.yaml', 'r') as f:
-                config = yaml.safe_load(f)
-        except:
-            with importlib.resources.open_text('datamint', 'logging.yaml') as f:
-                config = yaml.safe_load(f.read())
-
-        logging.config.dictConfig(config)
-    except Exception as e:
-        print(f"Warning: Error loading logging configuration file: {e}")
-        _LOGGER.exception(e)
-        logging.basicConfig(level=logging.INFO)