speedy-utils 1.1.42__py3-none-any.whl → 1.1.44__py3-none-any.whl

speedy_utils/multi_worker/thread.py

@@ -1,4 +1,7 @@
 from ..__imports import *
+import linecache
+
+from .process import ErrorStats, ErrorHandlerType
 
 
 try:
@@ -6,6 +9,17 @@ try:
 except ImportError:  # pragma: no cover
     tqdm = None  # type: ignore[assignment]
 
+try:
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.syntax import Syntax
+    from rich.text import Text
+except ImportError:  # pragma: no cover
+    Console = None  # type: ignore[assignment, misc]
+    Panel = None  # type: ignore[assignment, misc]
+    Syntax = None  # type: ignore[assignment, misc]
+    Text = None  # type: ignore[assignment, misc]
+
 # Sensible defaults
 DEFAULT_WORKERS = (os.cpu_count() or 4) * 2
 
@@ -25,11 +39,13 @@ class UserFunctionError(Exception):
         func_name: str,
         input_value: Any,
         user_traceback: list[traceback.FrameSummary],
+        caller_frame: traceback.FrameSummary | None = None,
     ) -> None:
         self.original_exception = original_exception
         self.func_name = func_name
         self.input_value = input_value
         self.user_traceback = user_traceback
+        self.caller_frame = caller_frame
 
         # Create a focused error message
         tb_str = ''.join(traceback.format_list(user_traceback))
@@ -44,6 +60,95 @@ class UserFunctionError(Exception):
         # Return focused error without infrastructure frames
         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:
+            # Fallback to plain text
+            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:
+                tb_parts.append(
+                    f'[cyan]{frame.filename}[/cyan]:[yellow]{frame.lineno}[/yellow] '
+                    f'in [green]{frame.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
 
 _PY_SET_ASYNC_EXC = ctypes.pythonapi.PyThreadState_SetAsyncExc
 try:
@@ -90,6 +195,7 @@ def _worker(
     item: T,
     func: Callable[[T], R],
     fixed_kwargs: Mapping[str, Any],
+    caller_frame: traceback.FrameSummary | None = None,
 ) -> R:
     """Execute the function with an item and fixed kwargs."""
     # Validate func is callable before attempting to call it
@@ -102,7 +208,7 @@ def _worker(
         )
 
     try:
-        return func(item, **fixed_kwargs)
+        return func(item)
     except Exception as exc:
         # Extract user code traceback (filter out infrastructure)
         exc_tb = sys.exc_info()[2]
@@ -114,8 +220,11 @@ def _worker(
             user_frames = []
             skip_patterns = [
                 'multi_worker/thread.py',
+                'multi_worker/process.py',
                 'concurrent/futures/',
                 'threading.py',
+                'multiprocessing/',
+                'site-packages/ray/',
             ]
 
             for frame in tb_list:
@@ -130,6 +239,7 @@ def _worker(
                     func_name,
                     item,
                     user_frames,
+                    caller_frame,
                 ) from exc
 
         # Fallback: re-raise original if we couldn't extract frames
@@ -140,8 +250,9 @@ def _run_batch(
     items: Sequence[T],
     func: Callable[[T], R],
     fixed_kwargs: Mapping[str, Any],
+    caller_frame: traceback.FrameSummary | None = None,
 ) -> list[R]:
-    return [_worker(item, func, fixed_kwargs) for item in items]
+    return [_worker(item, func, fixed_kwargs, caller_frame) for item in items]
 
 
 def _attach_metadata(fut: Future[Any], idx: int, logical_size: int) -> None:
@@ -242,7 +353,9 @@ def multi_thread(
     progress_update: int = 10,
     prefetch_factor: int = 4,
     timeout: float | None = None,
-    stop_on_error: bool = True,
+    stop_on_error: bool | None = None,
+    error_handler: ErrorHandlerType = 'raise',
+    max_error_files: int = 100,
     n_proc: int = 0,
     store_output_pkl_file: str | None = None,
     **fixed_kwargs: Any,
@@ -272,8 +385,16 @@ def multi_thread(
         Multiplier controlling in-flight items (``workers * prefetch_factor``).
     timeout : float | None, optional
         Overall wall-clock timeout in seconds.
-    stop_on_error : bool, optional
-        Abort immediately on the first exception when ``True``.
+    stop_on_error : bool | None, optional
+        Deprecated. Use error_handler instead.
+        When True -> error_handler='raise', when False -> error_handler='log'.
+    error_handler : 'raise' | 'ignore' | 'log', optional
+        - 'raise': raise exception on first error (default)
+        - 'ignore': continue, return None for failed items
+        - 'log': same as ignore, but logs errors to files
+    max_error_files : int, optional
+        Maximum number of error log files to write (default: 100).
+        Error logs are written to .cache/speedy_utils/error_logs/{idx}.log
     n_proc : int, optional
         Optional process-level fan-out; ``>1`` shards work across processes.
     store_output_pkl_file : str | None, optional
@@ -285,10 +406,20 @@ def multi_thread(
     -------
     list[R | None]
         Collected results, preserving order when requested. Failed tasks yield
-        ``None`` entries if ``stop_on_error`` is ``False``.
+        ``None`` entries if ``error_handler`` is not 'raise'.
     """
     from speedy_utils import dump_json_or_pickle, load_by_ext
 
+    # Handle deprecated stop_on_error parameter
+    if stop_on_error is not None:
+        import warnings
+        warnings.warn(
+            "stop_on_error is deprecated, use error_handler instead",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        error_handler = 'raise' if stop_on_error else 'log'
+
     if n_proc > 1:
         import tempfile
 
@@ -319,7 +450,8 @@ def multi_thread(
                 progress_update=progress_update,
                 prefetch_factor=prefetch_factor,
                 timeout=timeout,
-                stop_on_error=stop_on_error,
+                error_handler=error_handler,
+                max_error_files=max_error_files,
                 n_proc=0,
                 store_output_pkl_file=file_pkl,
                 **fixed_kwargs,
@@ -363,12 +495,30 @@ def multi_thread(
     if batch == 1 and logical_total and logical_total / max(workers_val, 1) > 20_000:
         batch = 32
 
-    src_iter: Iterable[Any] = iter(inputs)
+    src_iter: Iterator[Any] = iter(inputs)
     if batch > 1:
-        src_iter = _group_iter(src_iter, batch)
-    src_iter = iter(src_iter)
+        src_iter = iter(_group_iter(src_iter, batch))
     collector: _ResultCollector[Any] = _ResultCollector(ordered, logical_total)
 
+    # Initialize error stats for error handling
+    func_name = getattr(func, '__name__', repr(func))
+    error_stats = ErrorStats(
+        func_name=func_name,
+        max_error_files=max_error_files,
+        write_logs=error_handler == 'log'
+    )
+
+    # Convert inputs to list for index access in error logging
+    items_list: list[Any] | None = None
+    if error_handler != 'raise':
+        try:
+            items_list = list(inputs)
+            src_iter = iter(items_list)
+            if batch > 1:
+                src_iter = iter(_group_iter(src_iter, batch))
+        except Exception:
+            items_list = None
+
     bar = None
     last_bar_update = 0
     if (
@@ -382,10 +532,22 @@ def multi_thread(
             ncols=128,
             colour='green',
             bar_format=(
-                '{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, {rate_fmt}{postfix}]'
+                '{l_bar}{bar}| {n_fmt}/{total_fmt} '
+                '[{elapsed}<{remaining}, {rate_fmt}{postfix}]'
             ),
         )
 
+    # Capture caller context for error reporting
+    caller_frame_obj = inspect.currentframe()
+    caller_context: traceback.FrameSummary | None = None
+    if caller_frame_obj and caller_frame_obj.f_back:
+        caller_info = inspect.getframeinfo(caller_frame_obj.f_back)
+        caller_context = traceback.FrameSummary(
+            caller_info.filename,
+            caller_info.lineno,
+            caller_info.function,
+        )
+
     deadline = time.monotonic() + timeout if timeout is not None else None
     max_inflight = max(workers_val * prefetch_factor, 1)
     completed_items = 0
@@ -409,10 +571,10 @@ def multi_thread(
                 batch_items = list(arg)
                 if not batch_items:
                     return
-                fut = pool.submit(_run_batch, batch_items, func, fixed_kwargs_map)
+                fut = pool.submit(_run_batch, batch_items, func, fixed_kwargs_map, caller_context)
                 logical_size = len(batch_items)
             else:
-                fut = pool.submit(_worker, arg, func, fixed_kwargs_map)
+                fut = pool.submit(_worker, arg, func, fixed_kwargs_map, caller_context)
                 logical_size = 1
             _attach_metadata(fut, next_logical_idx, logical_size)
             next_logical_idx += logical_size
@@ -453,37 +615,37 @@ def multi_thread(
                 idx, logical_size = _future_meta(fut)
                 try:
                     result = fut.result()
+                    # Record success for each item in the batch
+                    for _ in range(logical_size):
+                        error_stats.record_success()
                 except UserFunctionError as exc:
-                    # User function error - already has clean traceback
-                    logger.error(str(exc))
-
-                    if stop_on_error:
+                    # User function error
+                    if error_handler == 'raise':
+                        sys.stderr.flush()
+                        sys.stdout.flush()
+                        exc.format_rich()
+                        sys.stderr.flush()
                         _cancel_futures(inflight)
-                        # Create a clean exception without infrastructure frames
-                        # by re-creating the traceback
-                        orig_exc = exc.original_exception
-
-                        # Build new traceback from user frames only
-                        tb_str = ''.join(traceback.format_list(exc.user_traceback))
-                        clean_msg = (
-                            f'\nError in "{exc.func_name}" '
-                            f'with input: {exc.input_value!r}\n\n{tb_str}'
-                            f'{type(orig_exc).__name__}: {orig_exc}'
-                        )
-
-                        # Raise a new instance of the original exception type
-                        # with our clean message
-                        new_exc = type(orig_exc)(clean_msg)
-                        # Suppress the "from" chain to avoid showing infrastructure
-                        raise new_exc from None
-
+                        sys.exit(1)
+                    
+                    # Log error with ErrorStats
+                    input_val = None
+                    if items_list is not None and idx < len(items_list):
+                        input_val = items_list[idx]
+                    error_stats.record_error(
+                        idx, exc.original_exception, input_val, func_name
+                    )
                     out_items = [None] * logical_size
                 except Exception as exc:
                     # Other errors (infrastructure, batching, etc.)
-                    if stop_on_error:
+                    if error_handler == 'raise':
                         _cancel_futures(inflight)
                         raise
-                    logger.exception('multi_thread task failed', exc_info=exc)
+                    
+                    input_val = None
+                    if items_list is not None and idx < len(items_list):
+                        input_val = items_list[idx]
+                    error_stats.record_error(idx, exc, input_val, func_name)
                     out_items = [None] * logical_size
                 else:
                     try:
@@ -503,15 +665,13 @@ def multi_thread(
                         bar.update(delta)
                         last_bar_update = completed_items
                         submitted = next_logical_idx
-                        pending = (
+                        pending: int | str = (
                             max(logical_total - submitted, 0)
                             if logical_total is not None
                             else '-'
                         )
-                        postfix = {
-                            'processing': min(len(inflight), workers_val),
-                            'pending': pending,
-                        }
+                        postfix: dict[str, Any] = error_stats.get_postfix_dict()
+                        postfix['pending'] = pending
                         bar.set_postfix(postfix)
 
             try:

{speedy_utils-1.1.42.dist-info → speedy_utils-1.1.44.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: speedy-utils
-Version: 1.1.42
+Version: 1.1.44
 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
@@ -17,7 +17,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Requires-Dist: aiohttp
 Requires-Dist: bump2version
 Requires-Dist: cachetools
@@ -39,6 +39,7 @@ Requires-Dist: pydantic
 Requires-Dist: pytest
 Requires-Dist: ray
 Requires-Dist: requests
+Requires-Dist: rich>=14.3.1
 Requires-Dist: ruff
 Requires-Dist: scikit-learn
 Requires-Dist: tabulate
@@ -57,13 +58,48 @@ 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)
@@ -72,11 +108,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
 
@@ -161,20 +198,132 @@ 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:
+
+```
+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.42.dist-info → speedy_utils-1.1.44.dist-info}/RECORD

@@ -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=IXnlSPMc_2GJTtkfnobzm6wKA15_JvGe40yG8VG43N4,2822
+speedy_utils/__init__.py,sha256=1ubAYR6P0cEZJLDt7KQLLxl6ylh-T7WE7HPP94-rVLI,3045
 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
@@ -45,9 +45,9 @@ speedy_utils/common/utils_print.py,sha256=AGDB7mgJnO00QkJBH6kJb46738q3GzMUZPwtQ2
 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=y3zat4uCj_Pz2Z6nWiSBnvvPws_w2HA8M_V0S4ERHsg,24768
+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=k4Ff4R2W0Ehet1zJ5nHQOfcsvOjnJzU6A2I18qw7_6M,21320
+speedy_utils/multi_worker/thread.py,sha256=E7o_iUCIKmgk1tFt7mZAFT7c5q229wVzWj-trmVsxVA,27254
 speedy_utils/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 speedy_utils/scripts/mpython.py,sha256=uJ-QPG43cyHUptMP4MnyH7IdSTh4mzVQAejy9o1cQoE,5068
 speedy_utils/scripts/openapi_client_codegen.py,sha256=GModmmhkvGnxljK4KczyixKDrk-VEcLaW5I0XT6tzWo,9657
@@ -55,7 +55,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.42.dist-info/METADATA,sha256=EWPvwJVrOh9P37W1tOiahbih2nbP9G4Z0xNqu8GKDWs,8071
-speedy_utils-1.1.42.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-speedy_utils-1.1.42.dist-info/entry_points.txt,sha256=rwn89AYfBUh9SRJtFbpp-u2JIKiqmZ2sczvqyO6s9cI,289
-speedy_utils-1.1.42.dist-info/RECORD,,
+speedy_utils-1.1.44.dist-info/METADATA,sha256=Y5wQ_VbeiPTcqUkOCEbEvOKZ-wnwKCF2nvGhSnU3AJs,13067
+speedy_utils-1.1.44.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+speedy_utils-1.1.44.dist-info/entry_points.txt,sha256=rwn89AYfBUh9SRJtFbpp-u2JIKiqmZ2sczvqyO6s9cI,289
+speedy_utils-1.1.44.dist-info/RECORD,,