speedy-utils 1.1.43__py3-none-any.whl → 1.1.45__py3-none-any.whl

llm_utils/lm/llm.py

@@ -16,6 +16,7 @@ from openai.types.chat import ChatCompletionMessageParam
 from pydantic import BaseModel
 
 from speedy_utils.common.utils_io import jdumps
+from speedy_utils import clean_traceback
 
 from .base_prompt_builder import BasePromptBuilder
 from .mixins import (
@@ -159,6 +160,7 @@ class LLM(
         messages.append({'role': 'user', 'content': user_content})
         return cast(Messages, messages)
 
+    @clean_traceback
     def text_completion(
         self, input_data: str | BaseModel | list[dict], **runtime_kwargs
     ) -> list[dict[str, Any]]:
@@ -214,6 +216,7 @@ class LLM(
             results.append(result_dict)
         return results
 
+    @clean_traceback
     def pydantic_parse(
         self,
         input_data: str | BaseModel | list[dict],

speedy_utils/__init__.py

@@ -58,6 +58,9 @@ from .common.utils_print import (
     fprint,
 )
 
+# Error handling utilities
+from .common.utils_error import clean_traceback, handle_exceptions_with_clean_traceback
+
 # Multi-worker processing
 from .multi_worker.process import multi_process
 from .multi_worker.thread import kill_all_thread, multi_thread
@@ -156,6 +159,9 @@ __all__ = [
     'print_table',
     'setup_logger',
     'log',
+    # Error handling utilities
+    'clean_traceback',
+    'handle_exceptions_with_clean_traceback',
     # Multi-worker processing
     'multi_process',
     'multi_thread',

speedy_utils/common/utils_error.py

@@ -0,0 +1,261 @@
+"""
+Error handling utilities for clean, user-focused tracebacks.
+"""
+
+import inspect
+import linecache
+import sys
+import traceback
+from typing import Any, Callable, TypeVar
+
+try:
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.text import Text
+except ImportError:
+    Console = None
+    Panel = None
+    Text = None
+
+F = TypeVar('F', bound=Callable[..., Any])
+
+
+class CleanTracebackError(Exception):
+    """Exception wrapper that provides clean, user-focused tracebacks."""
+
+    def __init__(
+        self,
+        original_exception: Exception,
+        user_traceback: list[traceback.FrameSummary],
+        caller_frame: traceback.FrameSummary | None = None,
+        func_name: str | None = None,
+    ) -> None:
+        self.original_exception = original_exception
+        self.user_traceback = user_traceback
+        self.caller_frame = caller_frame
+        self.func_name = func_name
+
+        # Create a focused error message
+        tb_str = ''.join(traceback.format_list(user_traceback))
+        func_part = f' in {func_name}' if func_name else ''
+        msg = (
+            f'Error{func_part}:\n'
+            f'\nUser code traceback:\n{tb_str}'
+            f'{type(original_exception).__name__}: {original_exception}'
+        )
+        super().__init__(msg)
+
+    def __str__(self) -> str:
+        return super().__str__()
+
+    def format_rich(self) -> None:
+        """Format and print error with rich panels and code context."""
+        if Console is None or Panel is None or Text is None:
+            print(str(self), file=sys.stderr)
+            return
+
+        console = Console(stderr=True, force_terminal=True)
+
+        # Build traceback display with code context
+        tb_parts: list[str] = []
+
+        # Show caller frame first if available
+        if self.caller_frame and self.caller_frame.lineno is not None:
+            tb_parts.append(
+                f'[cyan]{self.caller_frame.filename}[/cyan]:[yellow]{self.caller_frame.lineno}[/yellow] '
+                f'in [green]{self.caller_frame.name}[/green]'
+            )
+            tb_parts.append('')
+            context = _get_code_context_rich(self.caller_frame.filename, self.caller_frame.lineno, 3)
+            tb_parts.extend(context)
+            tb_parts.append('')
+
+        # Show user code frames with context
+        for frame in self.user_traceback:
+            if frame.lineno is not None:
+                func_name = f' {self.func_name}' if self.func_name else ''
+                tb_parts.append(
+                    f'[cyan]{frame.filename}[/cyan]:[yellow]{frame.lineno}[/yellow] '
+                    f'in [green]{frame.name}{func_name}[/green]'
+                )
+                tb_parts.append('')
+                context = _get_code_context_rich(frame.filename, frame.lineno, 3)
+                tb_parts.extend(context)
+                tb_parts.append('')
+
+        # Print with rich Panel
+        console.print()
+        console.print(
+            Panel(
+                '\n'.join(tb_parts),
+                title='[bold red]Traceback (most recent call last)[/bold red]',
+                border_style='red',
+                expand=False,
+            )
+        )
+        console.print(
+            f'[bold red]{type(self.original_exception).__name__}[/bold red]: '
+            f'{self.original_exception}'
+        )
+        console.print()
+
+
+def _get_code_context(filename: str, lineno: int, context_lines: int = 3) -> list[str]:
+    """Get code context around a line with line numbers and highlighting."""
+    lines: list[str] = []
+    start = max(1, lineno - context_lines)
+    end = lineno + context_lines
+
+    for i in range(start, end + 1):
+        line = linecache.getline(filename, i)
+        if not line:
+            continue
+        line = line.rstrip()
+        marker = '❱' if i == lineno else ' '
+        lines.append(f'  {i:4d} {marker} {line}')
+
+    return lines
+
+
+def _get_code_context_rich(filename: str, lineno: int, context_lines: int = 3) -> list[str]:
+    """Get code context with rich formatting (colors)."""
+    lines: list[str] = []
+    start = max(1, lineno - context_lines)
+    end = lineno + context_lines
+
+    for i in range(start, end + 1):
+        line = linecache.getline(filename, i)
+        if not line:
+            continue
+        line = line.rstrip()
+        num_str = f'{i:4d}'
+
+        if i == lineno:
+            # Highlight error line
+            lines.append(f'[dim]{num_str}[/dim] [red]❱[/red] {line}')
+        else:
+            # Normal context line
+            lines.append(f'[dim]{num_str} │[/dim] {line}')
+
+    return lines
+
+
+def _filter_traceback_frames(tb_list: list[traceback.FrameSummary]) -> list[traceback.FrameSummary]:
+    """Filter traceback frames to show only user code."""
+    user_frames = []
+    skip_patterns = [
+        'site-packages/',
+        'dist-packages/',
+        'python3.',
+        'lib/python',
+        'concurrent/futures/',
+        'threading.py',
+        'multiprocessing/',
+        'urllib/',
+        'httpx/',
+        'httpcore/',
+        'openai/',
+        'requests/',
+        'aiohttp/',
+        'urllib3/',
+        'speedy_utils/common/',
+        'speedy_utils/multi_worker/',
+        'llm_utils/lm/',
+        'llm_utils/chat_format/',
+        'llm_utils/vector_cache/',
+    ]
+
+    skip_functions = [
+        'wrapper',  # Our decorator wrapper
+        '__call__',  # Internal calls
+        '__inner_call__',  # Internal calls
+        '_worker',  # Multi-thread worker
+        '_run_batch',  # Batch runner
+    ]
+
+    for frame in tb_list:
+        # Skip frames matching skip patterns
+        if any(pattern in frame.filename for pattern in skip_patterns):
+            continue
+        # Skip specific function names
+        if frame.name in skip_functions:
+            continue
+        # Skip frames that are too deep in the call stack (internal implementation)
+        if 'speedy_utils' in frame.filename and any(
+            name in frame.name for name in ['__inner_call__', '_worker', '_run_batch']
+        ):
+            continue
+        user_frames.append(frame)
+
+    # If no user frames found, keep frames that are likely user code (not deep library internals)
+    if not user_frames:
+        for frame in reversed(tb_list):
+            # Keep if it's not in site-packages and not in standard library
+            if ('site-packages/' not in frame.filename and 
+                'dist-packages/' not in frame.filename and
+                not frame.filename.startswith('/usr/') and
+                not frame.filename.startswith('/opt/') and
+                'python3.' not in frame.filename and
+                frame.name not in skip_functions):
+                user_frames.append(frame)
+                if len(user_frames) >= 5:  # Keep up to 5 frames
+                    break
+        user_frames.reverse()
+
+    return user_frames
+
+
+def clean_traceback(func: F) -> F:
+    """Decorator to wrap function calls with clean traceback handling."""
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception as exc:
+            # Get the current traceback
+            exc_tb = sys.exc_info()[2]
+
+            if exc_tb is not None:
+                tb_list = traceback.extract_tb(exc_tb)
+
+                # Filter to keep only user code frames
+                user_frames = _filter_traceback_frames(tb_list)
+
+                # Get caller frame - walk up the stack to find the original caller
+                caller_context = None
+                frame = inspect.currentframe()
+                while frame:
+                    frame = frame.f_back
+                    if frame and frame.f_code.co_name not in ['wrapper', '__call__', '__inner_call__']:
+                        caller_info = inspect.getframeinfo(frame)
+                        if not any(skip in caller_info.filename for skip in [
+                            'speedy_utils/common/', 'speedy_utils/multi_worker/', 
+                            'llm_utils/lm/', 'site-packages/', 'dist-packages/'
+                        ]):
+                            caller_context = traceback.FrameSummary(
+                                caller_info.filename,
+                                caller_info.lineno,
+                                caller_info.function,
+                            )
+                            break
+
+                # If we have user frames, create and format our custom exception
+                if user_frames:
+                    func_name = getattr(func, '__name__', repr(func))
+                    clean_error = CleanTracebackError(
+                        exc,
+                        user_frames,
+                        caller_context,
+                        func_name,
+                    )
+                    clean_error.format_rich()
+                    sys.exit(1)  # Exit after formatting
+
+            # Fallback: re-raise original if we couldn't extract frames
+            raise
+
+    return wrapper  # type: ignore
+
+
+def handle_exceptions_with_clean_traceback(func: F) -> F:
+    """Alias for clean_traceback decorator."""
+    return clean_traceback(func)

speedy_utils/multi_worker/process.py

@@ -115,32 +115,39 @@ class ErrorStats:
         func_name: str,
     ) -> str:
         """Write error details to a log file."""
+        from io import StringIO
+        from rich.console import Console
+        
         log_path = self._error_log_dir / f'{idx}.log'
         
+        output = StringIO()
+        console = Console(file=output, width=120, no_color=False)
+        
         # Format traceback
         tb_lines = self._format_traceback(error)
         
-        content = []
-        content.append(f'{"=" * 60}')
-        content.append(f'Error at index: {idx}')
-        content.append(f'Function: {func_name}')
-        content.append(f'Error Type: {type(error).__name__}')
-        content.append(f'Error Message: {error}')
-        content.append(f'{"=" * 60}')
-        content.append('')
-        content.append('Input:')
-        content.append('-' * 40)
+        console.print(f'{"=" * 60}')
+        console.print(f'Error at index: {idx}')
+        console.print(f'Function: {func_name}')
+        console.print(f'Error Type: {type(error).__name__}')
+        console.print(f'Error Message: {error}')
+        console.print(f'{"=" * 60}')
+        console.print('')
+        console.print('Input:')
+        console.print('-' * 40)
         try:
-            content.append(repr(input_value))
+            import json
+            console.print(json.dumps(input_value, indent=2))
         except Exception:
-            content.append('<unable to repr input>')
-        content.append('')
-        content.append('Traceback:')
-        content.append('-' * 40)
-        content.extend(tb_lines)
+            console.print(repr(input_value))
+        console.print('')
+        console.print('Traceback:')
+        console.print('-' * 40)
+        for line in tb_lines:
+            console.print(line)
         
         with open(log_path, 'w') as f:
-            f.write('\n'.join(content))
+            f.write(output.getvalue())
         
         return str(log_path)
 
@@ -824,7 +831,7 @@ def multi_process(
     log_worker: Literal['zero', 'first', 'all'] = 'first',
     total_items: int | None = None,
     poll_interval: float = 0.3,
-    error_handler: ErrorHandlerType = 'raise',
+    error_handler: ErrorHandlerType = 'log',
     max_error_files: int = 100,
     **func_kwargs: Any,
 ) -> list[Any]:

{speedy_utils-1.1.43.dist-info → speedy_utils-1.1.45.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: speedy-utils
-Version: 1.1.43
+Version: 1.1.45
 Summary: Fast and easy-to-use package for data science
 Project-URL: Homepage, https://github.com/anhvth/speedy
 Project-URL: Repository, https://github.com/anhvth/speedy
@@ -58,13 +58,49 @@ Description-Content-Type: text/markdown
 
 **Speedy Utils** is a Python utility library designed to streamline common programming tasks such as caching, parallel processing, file I/O, and data manipulation. It provides a collection of decorators, functions, and classes to enhance productivity and performance in your Python projects.
 
+## 🚀 Recent Updates (January 27, 2026)
+
+**Enhanced Error Handling in Parallel Processing:**
+
+- Rich-formatted error tracebacks with code context and syntax highlighting
+- Three error handling modes: 'raise', 'ignore', and 'log'
+- Filtered tracebacks focusing on user code (hiding infrastructure)
+- Real-time progress reporting with error/success statistics
+- Automatic error logging to timestamped files
+- Caller frame information showing where parallel functions were invoked
+
+## Quick Start
+
+### Parallel Processing with Error Handling
+
+```python
+from speedy_utils import multi_thread, multi_process
+
+# Simple parallel processing
+results = multi_thread(lambda x: x * 2, [1, 2, 3, 4, 5])
+# Results: [2, 4, 6, 8, 10]
+
+# Robust processing with error handling
+def process_item(item):
+    if item == 3:
+        raise ValueError(f"Cannot process item {item}")
+    return item * 2
+
+# Continue processing despite errors
+results = multi_thread(process_item, [1, 2, 3, 4, 5], error_handler='log')
+# Results: [2, 4, None, 8, 10] - errors logged automatically
+```
+
 ## Table of Contents
 
+- [🚀 Recent Updates](#-recent-updates-january-27-2026)
+- [Quick Start](#quick-start)
 - [Features](#features)
 - [Installation](#installation)
 - [Usage](#usage)
-  - [Caching](#caching)
   - [Parallel Processing](#parallel-processing)
+  - [Enhanced Error Handling](#enhanced-error-handling)
+  - [Caching](#caching)
   - [File I/O](#file-io)
   - [Data Manipulation](#data-manipulation)
   - [Utility Functions](#utility-functions)
@@ -73,11 +109,12 @@ Description-Content-Type: text/markdown
 ## Features
 
 - **Caching Mechanisms**: Disk-based and in-memory caching to optimize function calls.
-- **Parallel Processing**: Multi-threading, multi-processing, and asynchronous multi-threading utilities.
+- **Parallel Processing**: Multi-threading, multi-processing, and asynchronous multi-threading utilities with enhanced error handling.
 - **File I/O**: Simplified JSON, JSONL, and pickle file handling with support for various file extensions.
 - **Data Manipulation**: Utilities for flattening lists and dictionaries, converting data types, and more.
 - **Timing Utilities**: Tools to measure and log execution time of functions and processes.
 - **Pretty Printing**: Enhanced printing functions for structured data, including HTML tables for Jupyter notebooks.
+- **Enhanced Error Handling**: Rich error tracebacks with code context, configurable error handling modes ('raise', 'ignore', 'log'), and detailed progress reporting.
 
 ## Installation
 
@@ -162,20 +199,133 @@ result = compute_sum(5, 7)  # Retrieved from in-memory cache
 
 ### Parallel Processing
 
-#### Multi-threading
+#### Multi-threading with Enhanced Error Handling
 
-Execute functions concurrently using multiple threads. This approach is straightforward and automatically handles both notebook and Python script executions. In a notebook environment, it delegates the running thread to a separate process. If interrupted, it immediately stops this process, avoiding thread dependency issues where threads continue running until all tasks are completed.
+Execute functions concurrently using multiple threads with comprehensive error handling. The enhanced error handling provides three modes: 'raise' (default), 'ignore', and 'log'. When errors occur, you'll see rich-formatted tracebacks with code context and caller information.
 
 ```python
 from speedy_utils import multi_thread
 
 def process_item(item):
-    # Your processing logic
+    # Simulate processing that might fail
+    if item == 3:
+        raise ValueError(f"Invalid item: {item}")
     return item * 2
 
 items = [1, 2, 3, 4, 5]
-results = multi_thread(process_item, items, workers=3)
-print(results)  # [2, 4, 6, 8, 10]
+
+# Default behavior: raise on first error with rich traceback
+try:
+    results = multi_thread(process_item, items, workers=3)
+except SystemExit:
+    print("Error occurred and was displayed with rich formatting")
+
+# Continue processing on errors, return None for failed items
+results = multi_thread(process_item, items, workers=3, error_handler='ignore')
+print(results)  # [2, 4, None, 8, 10]
+
+# Log errors to files and continue processing
+results = multi_thread(process_item, items, workers=3, error_handler='log', max_error_files=10)
+print(results)  # [2, 4, None, 8, 10] - errors logged to .cache/speedy_utils/error_logs/
+```
+
+#### Multi-processing with Error Handling
+
+Process items across multiple processes with the same enhanced error handling capabilities.
+
+```python
+from speedy_utils import multi_process
+
+def risky_computation(x):
+    """Computation that might fail for certain inputs."""
+    if x % 5 == 0:
+        raise RuntimeError(f"Cannot process multiples of 5: {x}")
+    return x ** 2
+
+data = list(range(12))
+
+# Process with error logging (continues on errors)
+results = multi_process(
+    risky_computation, 
+    data, 
+    backend='mp',
+    error_handler='log',
+    max_error_files=5
+)
+print(results)  # [0, 1, 4, 9, 16, None, 36, 49, 64, 81, None, 121]
+```
+
+### Enhanced Error Handling
+
+**Speedy Utils** now provides comprehensive error handling for parallel processing with rich formatting and detailed diagnostics.
+
+#### Rich Error Tracebacks
+
+When errors occur, you'll see beautifully formatted tracebacks with:
+
+- **Code context**: Lines of code around the error location
+- **Caller information**: Shows where the parallel function was invoked
+- **Filtered frames**: Focuses on user code, hiding infrastructure details
+- **Color coding**: Easy-to-read formatting with syntax highlighting
+
+#### Error Handling Modes
+
+Choose how to handle errors in parallel processing:
+
+- **`'raise'` (default)**: Stop on first error with detailed traceback
+- **`'ignore'`**: Continue processing, return `None` for failed items  
+- **`'log'`**: Log errors to files and continue processing
+
+#### Error Logging
+
+When using `error_handler='log'`, errors are automatically saved to timestamped files in `.cache/speedy_utils/error_logs/` with full context and stack traces.
+
+#### Progress Reporting with Error Statistics
+
+Progress bars now show real-time error and success counts:
+
+```bash
+Multi-thread [8/10] [00:02<00:00, 3.45it/s, success=8, errors=2, pending=0]
+```
+
+This makes it easy to monitor processing health at a glance.
+
+#### Example: Robust Data Processing
+
+```python
+from speedy_utils import multi_thread
+
+def process_data_record(record):
+    """Process a data record that might have issues."""
+    try:
+        # Your processing logic here
+        value = record['value'] / record['divisor']
+        return {'result': value, 'status': 'success'}
+    except KeyError as e:
+        raise ValueError(f"Missing required field in record: {e}")
+    except ZeroDivisionError:
+        raise ValueError("Division by zero in record")
+
+# Sample data with some problematic records
+data = [
+    {'value': 10, 'divisor': 2},     # OK
+    {'value': 15, 'divisor': 0},     # Will error
+    {'value': 20, 'divisor': 4},     # OK
+    {'value': 25},                   # Missing divisor - will error
+]
+
+# Process with error logging - continues despite errors
+results = multi_thread(
+    process_data_record, 
+    data, 
+    workers=4,
+    error_handler='log',
+    max_error_files=10
+)
+
+print("Results:", results)
+# Output: Results: [{'result': 5.0, 'status': 'success'}, None, {'result': 5.0, 'status': 'success'}, None]
+# Errors are logged to files for later analysis
 ```
 
 ### File I/O

{speedy_utils-1.1.43.dist-info → speedy_utils-1.1.45.dist-info}/RECORD

@@ -7,7 +7,7 @@ llm_utils/chat_format/transform.py,sha256=PJ2g9KT1GSbWuAs7giEbTpTAffpU9QsIXyRlbf
 llm_utils/chat_format/utils.py,sha256=M2EctZ6NeHXqFYufh26Y3CpSphN0bdZm5xoNaEJj5vg,1251
 llm_utils/lm/__init__.py,sha256=4jYMy3wPH3tg-tHFyWEWOqrnmX4Tu32VZCdzRGMGQsI,778
 llm_utils/lm/base_prompt_builder.py,sha256=_TzYMsWr-SsbA_JNXptUVN56lV5RfgWWTrFi-E8LMy4,12337
-llm_utils/lm/llm.py,sha256=4nTBNvIZfsKUZo5SdllLQOp3w-HohR3B1hcfUnYDl7A,20014
+llm_utils/lm/llm.py,sha256=i6L5aKF6NhzmaFPBA2pCm8TkQmS1nCgORMqP5QyfJ28,20097
 llm_utils/lm/llm_signature.py,sha256=vV8uZgLLd6ZKqWbq0OPywWvXAfl7hrJQnbtBF-VnZRU,1244
 llm_utils/lm/lm_base.py,sha256=Bk3q34KrcCK_bC4Ryxbc3KqkiPL39zuVZaBQ1i6wJqs,9437
 llm_utils/lm/mixins.py,sha256=Nz7CwJFBOvbZNbODUlJC04Pcbac3zWnT8vy7sZG_MVI,24906
@@ -30,7 +30,7 @@ llm_utils/vector_cache/core.py,sha256=VXuYJy1AX22NHKvIXRriETip5RrmQcNp73-g-ZT774
 llm_utils/vector_cache/types.py,sha256=CpMZanJSTeBVxQSqjBq6pBVWp7u2-JRcgY9t5jhykdQ,438
 llm_utils/vector_cache/utils.py,sha256=OsiRFydv8i8HiJtPL9hh40aUv8I5pYfg2zvmtDi4DME,1446
 speedy_utils/__imports.py,sha256=V0YzkDK4-QkK_IDXY1be6C6_STuNhXAKIp4_dM0coQs,7800
-speedy_utils/__init__.py,sha256=1ubAYR6P0cEZJLDt7KQLLxl6ylh-T7WE7HPP94-rVLI,3045
+speedy_utils/__init__.py,sha256=_kSjS816Kv5UZPd4EM_juB68tXM_sHUYt6OFB-RhE6U,3261
 speedy_utils/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 speedy_utils/common/clock.py,sha256=raLtMGIgzrRej5kUt7hOUm2ZZw2THVPo-q8dMvdZOxw,7354
 speedy_utils/common/function_decorator.py,sha256=GKXqRs_hHFFmhyhql0Br0o52WzekUnpNlm99NfaVwgY,2025
@@ -39,13 +39,14 @@ speedy_utils/common/notebook_utils.py,sha256=6mxXZcTHwYob3nobAzbSZnDyXRahFaaSko1
 speedy_utils/common/patcher.py,sha256=Rku-N4DJNue8BCLUx7y3ad_3t_WU2HleHKlbR0vhaRc,2319
 speedy_utils/common/report_manager.py,sha256=78KQ0gUzvbzT6EjHYZ5zgtV41cPRvdX8hnF2oSWA4qA,3849
 speedy_utils/common/utils_cache.py,sha256=1UAqOSb4nFVlhuQRfTEXCN-8Wf6yntXyMA6yp61-98I,26277
+speedy_utils/common/utils_error.py,sha256=KQx2JTZsvsX2DsKRIoVR-4rc-6-l3OzEz9UtnHt8HJg,9108
 speedy_utils/common/utils_io.py,sha256=94m_EZ2eIs3w2m0rx-QQWsREPpVJctpweYHco3byczQ,15876
 speedy_utils/common/utils_misc.py,sha256=ZRJCS7OJxybpVm1sasoeCYRW2TaaGCXj4DySYlQeVR8,2227
 speedy_utils/common/utils_print.py,sha256=AGDB7mgJnO00QkJBH6kJb46738q3GzMUZPwtQ248vQw,4763
 speedy_utils/multi_worker/__init__.py,sha256=urcuxzaAJp-Rl3SIwHNre3x2vyHxLR7YGiDdm-Q8GQs,361
 speedy_utils/multi_worker/dataset_ray.py,sha256=U_l_4Y7CVpaHiApsXQSdNvals8NK87LHPS_XHiJF3qs,10044
 speedy_utils/multi_worker/parallel_gpu_pool.py,sha256=A7llZcQbRVZqwCqNRku7TpqGCdSoIzpdcTaupgqT5nI,6108
-speedy_utils/multi_worker/process.py,sha256=EujMtc9NqDVPqGOrLjlM6k60vEpRmOvlIJAYPKRQO6I,45237
+speedy_utils/multi_worker/process.py,sha256=U-pjHoWZ3xOeplMl2nSxVeiJE0F9V-eswpSdK-8c3dU,45446
 speedy_utils/multi_worker/progress.py,sha256=Ozeca-t-j1224n_dWwZkWzva9DC16SCLgScKeGtXLaQ,4717
 speedy_utils/multi_worker/thread.py,sha256=E7o_iUCIKmgk1tFt7mZAFT7c5q229wVzWj-trmVsxVA,27254
 speedy_utils/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -55,7 +56,7 @@ vision_utils/README.md,sha256=AIDZZj8jo_QNrEjFyHwd00iOO431s-js-M2dLtVTn3I,5740
 vision_utils/__init__.py,sha256=hF54sT6FAxby8kDVhOvruy4yot8O-Ateey5n96O1pQM,284
 vision_utils/io_utils.py,sha256=pI0Va6miesBysJcllK6NXCay8HpGZsaMWwlsKB2DMgA,26510
 vision_utils/plot.py,sha256=HkNj3osA3moPuupP1VguXfPPOW614dZO5tvC-EFKpKM,12028
-speedy_utils-1.1.43.dist-info/METADATA,sha256=IiZqjlKf2KUOwRDLZd0TusT3T5PECy5YRJssiw8wHAo,8099
-speedy_utils-1.1.43.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-speedy_utils-1.1.43.dist-info/entry_points.txt,sha256=rwn89AYfBUh9SRJtFbpp-u2JIKiqmZ2sczvqyO6s9cI,289
-speedy_utils-1.1.43.dist-info/RECORD,,
+speedy_utils-1.1.45.dist-info/METADATA,sha256=yXr9vEuXiRpvZ3VibGULqr3X1a832aQZJAb-lJLM6mM,13073
+speedy_utils-1.1.45.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+speedy_utils-1.1.45.dist-info/entry_points.txt,sha256=rwn89AYfBUh9SRJtFbpp-u2JIKiqmZ2sczvqyO6s9cI,289
+speedy_utils-1.1.45.dist-info/RECORD,,