datamint 1.9.2__tar.gz → 1.9.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: datamint
-Version: 1.9.2
+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

{datamint-1.9.2 → 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.2 → 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'")
@@ -225,6 +224,8 @@ class RootAPIHandler(BaseAPIHandler):
         async with aiohttp.ClientSession() as session:
             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,
@@ -238,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))
@@ -295,18 +302,17 @@ class RootAPIHandler(BaseAPIHandler):
         if new_len != orig_len:
             _LOGGER.info(f"Assembled {new_len} dicom files out of {orig_len} files.")
             mapping_idx = [None] * len(files_path)
-            files_path = itertools.chain(dicoms_files_path, other_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
-            # mapping_idx = [[dicom_original_idxs[i] for i in idxlist]
-            #                for idxlist in dicoms_files_path.mapping_idx]
-            # mapping_idx += [[i] for i in others_original_idxs]
         else:
             assembled = False
-            # mapping_idx = [[i] for i in range(len(files_path))]
+            mapping_idx = [i for i in range(len(files_path))]
 
         return files_path, assembled, mapping_idx
 
@@ -391,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]
@@ -412,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.
@@ -485,6 +493,11 @@ class RootAPIHandler(BaseAPIHandler):
             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:
@@ -513,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:
@@ -623,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']
 

{datamint-1.9.2 → 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():
@@ -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.2 → datamint-1.9.3}/datamint/client_cmd_tools/datamint_upload.py

@@ -12,8 +12,8 @@ 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
@@ -22,32 +22,42 @@ 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
@@ -56,7 +66,7 @@ def _get_minimal_distinguishing_paths(file_paths: list[str]) -> dict[str, str]:
         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):
@@ -67,12 +77,12 @@ def _get_minimal_distinguishing_paths(file_paths: list[str]) -> dict[str, str]:
                         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):
@@ -80,10 +90,8 @@ def _get_minimal_distinguishing_paths(file_paths: list[str]) -> dict[str, str]:
                 else:
                     distinguishing_path = '/'.join(parts[-max_depth_needed:])
                 result[file_paths[idx]] = distinguishing_path
-    
-    return result
-
 
+    return result
 
 
 def _read_segmentation_names(segmentation_names_path: str | Path) -> dict:
@@ -257,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:")
@@ -524,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=[],
@@ -541,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",
@@ -581,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)
@@ -594,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]
@@ -720,24 +736,26 @@ def print_results_summary(files_path: list[str],
     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)}")
     if len(failure_files) > 0:
-        _USER_LOGGER.info(f"\t❌ Failed uploads: {len(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):
             if isinstance(r, Exception):
                 _USER_LOGGER.warning(f"\t{distinguishing_paths[f]}: {r}")
     else:
-        _USER_LOGGER.info(f'✅ All uploads successful!')
+        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()
@@ -745,48 +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.")
+                return
+        #######################################
 
-    has_a_dicom_file = any(is_dicom(f) for f in files_path)
+        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
-                                               )
-    except pydicom.errors.InvalidDicomError as e:
-        _USER_LOGGER.error(f'❌ Invalid DICOM file: {e}')
-        return
-    _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:
+        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
+        _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.2 → 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.2 → 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.2"
+version = "1.9.3"
 dynamic = ["dependencies"]
 requires-python = ">=3.10"
 readme = "README.md"

datamint-1.9.2/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)