speedy-utils 1.1.23__py3-none-any.whl → 1.1.24__py3-none-any.whl

speedy_utils/multi_worker/thread.py

@@ -80,8 +80,10 @@
 
 import ctypes
 import os
+import sys
 import threading
 import time
+import traceback
 from collections.abc import Callable, Iterable, Mapping, Sequence
 from concurrent.futures import FIRST_COMPLETED, Future, ThreadPoolExecutor, wait
 from heapq import heappop, heappush
@@ -99,12 +101,42 @@ except ImportError:  # pragma: no cover
 # Sensible defaults
 DEFAULT_WORKERS = (os.cpu_count() or 4) * 2
 
-T = TypeVar('T')
-R = TypeVar('R')
+T = TypeVar("T")
+R = TypeVar("R")
 
 SPEEDY_RUNNING_THREADS: list[threading.Thread] = []  # cooperative shutdown tracking
 _SPEEDY_THREADS_LOCK = threading.Lock()
 
+
+class UserFunctionError(Exception):
+    """Exception wrapper that highlights user function errors."""
+
+    def __init__(
+        self,
+        original_exception: Exception,
+        func_name: str,
+        input_value: Any,
+        user_traceback: list[traceback.FrameSummary],
+    ) -> None:
+        self.original_exception = original_exception
+        self.func_name = func_name
+        self.input_value = input_value
+        self.user_traceback = user_traceback
+
+        # Create a focused error message
+        tb_str = "".join(traceback.format_list(user_traceback))
+        msg = (
+            f'\nError in function "{func_name}" with input: {input_value!r}\n'
+            f"\nUser code traceback:\n{tb_str}"
+            f"{type(original_exception).__name__}: {original_exception}"
+        )
+        super().__init__(msg)
+
+    def __str__(self) -> str:
+        # Return focused error without infrastructure frames
+        return super().__str__()
+
+
 _PY_SET_ASYNC_EXC = ctypes.pythonapi.PyThreadState_SetAsyncExc
 try:
     _PY_SET_ASYNC_EXC.argtypes = (ctypes.c_ulong, ctypes.py_object)  # type: ignore[attr-defined]
@@ -133,7 +165,7 @@ def _track_threads(threads: Iterable[threading.Thread]) -> None:
 
 
 def _track_executor_threads(pool: ThreadPoolExecutor) -> None:
-    thread_set = getattr(pool, '_threads', None)
+    thread_set = getattr(pool, "_threads", None)
     if not thread_set:
         return
     _track_threads(tuple(thread_set))
@@ -152,7 +184,48 @@ def _worker(
     fixed_kwargs: Mapping[str, Any],
 ) -> R:
     """Execute the function with an item and fixed kwargs."""
-    return func(item, **fixed_kwargs)
+    # Validate func is callable before attempting to call it
+    if not callable(func):
+        func_type = type(func).__name__
+        raise TypeError(
+            f"\nmulti_thread: func parameter must be callable, "
+            f"got {func_type}: {func!r}\n"
+            f"Hint: Did you accidentally pass a {func_type} instead of a function?"
+        )
+
+    try:
+        return func(item, **fixed_kwargs)
+    except Exception as exc:
+        # Extract user code traceback (filter out infrastructure)
+        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 = []
+            skip_patterns = [
+                "multi_worker/thread.py",
+                "concurrent/futures/",
+                "threading.py",
+            ]
+
+            for frame in tb_list:
+                if not any(pattern in frame.filename for pattern in skip_patterns):
+                    user_frames.append(frame)
+
+            # If we have user frames, wrap in our custom exception
+            if user_frames:
+                func_name = getattr(func, "__name__", repr(func))
+                raise UserFunctionError(
+                    exc,
+                    func_name,
+                    item,
+                    user_frames,
+                ) from exc
+
+        # Fallback: re-raise original if we couldn't extract frames
+        raise
 
 
 def _run_batch(
@@ -164,14 +237,14 @@ def _run_batch(
 
 
 def _attach_metadata(fut: Future[Any], idx: int, logical_size: int) -> None:
-    setattr(fut, '_speedy_idx', idx)
-    setattr(fut, '_speedy_size', logical_size)
+    setattr(fut, "_speedy_idx", idx)
+    setattr(fut, "_speedy_size", logical_size)
 
 
 def _future_meta(fut: Future[Any]) -> tuple[int, int]:
     return (
-        getattr(fut, '_speedy_idx'),
-        getattr(fut, '_speedy_size'),
+        getattr(fut, "_speedy_idx"),
+        getattr(fut, "_speedy_size"),
     )
 
 
@@ -219,7 +292,7 @@ def _resolve_worker_count(workers: int | None) -> int:
     if workers is None:
         return DEFAULT_WORKERS
     if workers <= 0:
-        raise ValueError('workers must be a positive integer')
+        raise ValueError("workers must be a positive integer")
     return workers
 
 
@@ -227,18 +300,18 @@ def _normalize_batch_result(result: Any, logical_size: int) -> list[Any]:
     if logical_size == 1:
         return [result]
     if result is None:
-        raise ValueError('batched callable returned None for a batch result')
+        raise ValueError("batched callable returned None for a batch result")
     if isinstance(result, (str, bytes, bytearray)):
-        raise TypeError('batched callable must not return str/bytes when batching')
+        raise TypeError("batched callable must not return str/bytes when batching")
     if isinstance(result, Sequence):
         out = list(result)
     elif isinstance(result, Iterable):
         out = list(result)
     else:
-        raise TypeError('batched callable must return an iterable of results')
+        raise TypeError("batched callable must return an iterable of results")
     if len(out) != logical_size:
         raise ValueError(
-            f'batched callable returned {len(out)} items, expected {logical_size}',
+            f"batched callable returned {len(out)} items, expected {logical_size}",
         )
     return out
 
@@ -325,7 +398,7 @@ def multi_thread(
         results: list[R | None] = []
 
         for proc_idx, chunk in enumerate(chunks):
-            with tempfile.NamedTemporaryFile(delete=False, suffix='multi_thread.pkl') as fh:
+            with tempfile.NamedTemporaryFile(delete=False, suffix="multi_thread.pkl") as fh:
                 file_pkl = fh.name
             assert isinstance(in_process_multi_thread, Callable)
             proc = in_process_multi_thread(
@@ -347,28 +420,28 @@ def multi_thread(
 
         for proc, file_pkl in procs:
             proc.join()
-            logger.info('process finished: %s', proc)
+            logger.info("process finished: %s", proc)
             try:
                 results.extend(load_by_ext(file_pkl))
             finally:
                 try:
                     os.unlink(file_pkl)
                 except OSError as exc:  # pragma: no cover - best effort cleanup
-                    logger.warning('failed to remove temp file %s: %s', file_pkl, exc)
+                    logger.warning("failed to remove temp file %s: %s", file_pkl, exc)
         return results
 
     try:
         import pandas as pd
 
         if isinstance(inputs, pd.DataFrame):
-            inputs = cast(Iterable[T], inputs.to_dict(orient='records'))
+            inputs = cast(Iterable[T], inputs.to_dict(orient="records"))
     except ImportError:  # pragma: no cover - optional dependency
         pass
 
     if batch <= 0:
-        raise ValueError('batch must be a positive integer')
+        raise ValueError("batch must be a positive integer")
     if prefetch_factor <= 0:
-        raise ValueError('prefetch_factor must be a positive integer')
+        raise ValueError("prefetch_factor must be a positive integer")
 
     workers_val = _resolve_worker_count(workers)
     progress_update = max(progress_update, 1)
@@ -390,20 +463,12 @@ def multi_thread(
 
     bar = None
     last_bar_update = 0
-    if (
-        progress
-        and tqdm is not None
-        and logical_total is not None
-        and logical_total > 0
-    ):
+    if progress and tqdm is not None and logical_total is not None and logical_total > 0:
         bar = tqdm(
             total=logical_total,
             ncols=128,
-            colour='green',
-            bar_format=(
-                '{l_bar}{bar}| {n_fmt}/{total_fmt}'
-                ' [{elapsed}<{remaining}, {rate_fmt}{postfix}]'
-            ),
+            colour="green",
+            bar_format=("{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, {rate_fmt}{postfix}]"),
         )
 
     deadline = time.monotonic() + timeout if timeout is not None else None
@@ -417,11 +482,12 @@ def multi_thread(
     inflight: set[Future[Any]] = set()
     pool = ThreadPoolExecutor(
         max_workers=workers_val,
-        thread_name_prefix='speedy-thread',
+        thread_name_prefix="speedy-thread",
     )
-    shutdown_kwargs: dict[str, Any] = {'wait': True}
+    shutdown_kwargs: dict[str, Any] = {"wait": True}
 
     try:
+
         def submit_arg(arg: Any) -> None:
             nonlocal next_logical_idx
             if batch > 1:
@@ -451,7 +517,7 @@ def multi_thread(
                 if remaining <= 0:
                     _cancel_futures(inflight)
                     raise TimeoutError(
-                        f'multi_thread timed out after {timeout} seconds',
+                        f"multi_thread timed out after {timeout} seconds",
                     )
                 wait_timeout = max(remaining, 0.0)
 
@@ -464,7 +530,7 @@ def multi_thread(
             if not done:
                 _cancel_futures(inflight)
                 raise TimeoutError(
-                    f'multi_thread timed out after {timeout} seconds',
+                    f"multi_thread timed out after {timeout} seconds",
                 )
 
             for fut in done:
@@ -472,11 +538,37 @@ def multi_thread(
                 idx, logical_size = _future_meta(fut)
                 try:
                     result = fut.result()
+                except UserFunctionError as exc:
+                    # User function error - already has clean traceback
+                    logger.error(str(exc))
+
+                    if stop_on_error:
+                        _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
+
+                    out_items = [None] * logical_size
                 except Exception as exc:
+                    # Other errors (infrastructure, batching, etc.)
                     if stop_on_error:
                         _cancel_futures(inflight)
                         raise
-                    logger.exception('multi_thread task failed', exc_info=exc)
+                    logger.exception("multi_thread task failed", exc_info=exc)
                     out_items = [None] * logical_size
                 else:
                     try:
@@ -484,7 +576,7 @@ def multi_thread(
                     except Exception as exc:
                         _cancel_futures(inflight)
                         raise RuntimeError(
-                            'batched callable returned an unexpected shape',
+                            "batched callable returned an unexpected shape",
                         ) from exc
 
                 collector.add(idx, out_items)
@@ -496,14 +588,10 @@ def multi_thread(
                         bar.update(delta)
                         last_bar_update = completed_items
                         submitted = next_logical_idx
-                        pending = (
-                            max(logical_total - submitted, 0)
-                            if logical_total is not None
-                            else '-'
-                        )
+                        pending = max(logical_total - submitted, 0) if logical_total is not None else "-"
                         postfix = {
-                            'processing': min(len(inflight), workers_val),
-                            'pending': pending,
+                            "processing": min(len(inflight), workers_val),
+                            "pending": pending,
                         }
                         bar.set_postfix(postfix)
 
@@ -516,7 +604,7 @@ def multi_thread(
         results = collector.finalize()
 
     except KeyboardInterrupt:
-        shutdown_kwargs = {'wait': False, 'cancel_futures': True}
+        shutdown_kwargs = {"wait": False, "cancel_futures": True}
         _cancel_futures(inflight)
         kill_all_thread(SystemExit)
         raise KeyboardInterrupt() from None
@@ -524,29 +612,27 @@ def multi_thread(
         try:
             pool.shutdown(**shutdown_kwargs)
         except TypeError:  # pragma: no cover - Python <3.9 fallback
-            pool.shutdown(shutdown_kwargs.get('wait', True))
+            pool.shutdown(shutdown_kwargs.get("wait", True))
         if bar:
             delta = completed_items - last_bar_update
             if delta > 0:
                 bar.update(delta)
             bar.close()
 
-    results = collector.finalize() if 'results' not in locals() else results
+    results = collector.finalize() if "results" not in locals() else results
     if store_output_pkl_file:
         dump_json_or_pickle(results, store_output_pkl_file)
     _prune_dead_threads()
     return results
 
 
-def multi_thread_standard(
-    fn: Callable[[T], R], items: Iterable[T], workers: int = 4
-) -> list[R]:
+def multi_thread_standard(fn: Callable[[T], R], items: Iterable[T], workers: int = 4) -> list[R]:
     """Execute ``fn`` across ``items`` while preserving submission order."""
 
     workers_val = _resolve_worker_count(workers)
     with ThreadPoolExecutor(
         max_workers=workers_val,
-        thread_name_prefix='speedy-thread',
+        thread_name_prefix="speedy-thread",
     ) as executor:
         futures: list[Future[R]] = []
         for item in items:
@@ -561,13 +647,13 @@ def _async_raise(thread_id: int, exc_type: type[BaseException]) -> bool:
     if thread_id <= 0:
         return False
     if not issubclass(exc_type, BaseException):
-        raise TypeError('exc_type must derive from BaseException')
+        raise TypeError("exc_type must derive from BaseException")
     res = _PY_SET_ASYNC_EXC(ctypes.c_ulong(thread_id), ctypes.py_object(exc_type))
     if res == 0:
         return False
     if res > 1:  # pragma: no cover - defensive branch
         _PY_SET_ASYNC_EXC(ctypes.c_ulong(thread_id), None)
-        raise SystemError('PyThreadState_SetAsyncExc failed')
+        raise SystemError("PyThreadState_SetAsyncExc failed")
     return True
 
 
@@ -596,16 +682,17 @@ def kill_all_thread(exc_type: type[BaseException] = SystemExit, join_timeout: fl
                 terminated += 1
                 thread.join(timeout=join_timeout)
             else:
-                logger.warning('Unable to signal thread %s', thread.name)
+                logger.warning("Unable to signal thread %s", thread.name)
         except Exception as exc:  # pragma: no cover - defensive
-            logger.error('Failed to stop thread %s: %s', thread.name, exc)
+            logger.error("Failed to stop thread %s: %s", thread.name, exc)
     _prune_dead_threads()
     return terminated
 
 
 __all__ = [
-    'SPEEDY_RUNNING_THREADS',
-    'multi_thread',
-    'multi_thread_standard',
-    'kill_all_thread',
+    "SPEEDY_RUNNING_THREADS",
+    "UserFunctionError",
+    "multi_thread",
+    "multi_thread_standard",
+    "kill_all_thread",
 ]

{speedy_utils-1.1.23.dist-info → speedy_utils-1.1.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: speedy-utils
-Version: 1.1.23
+Version: 1.1.24
 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

{speedy_utils-1.1.23.dist-info → speedy_utils-1.1.24.dist-info}/RECORD

@@ -1,17 +1,18 @@
-llm_utils/__init__.py,sha256=gUmdXk6DF7dTKgYr23LdnkXLNT6x8bUZoacKQJ9pi8I,1625
+llm_utils/__init__.py,sha256=pbnOQddU5KnhP8uqMqN9E87BeDeCxFrgta2m2P89LmM,1591
 llm_utils/group_messages.py,sha256=Oe2tlhg-zRodG1-hodYebddrR77j9UdE05LzJw0EvYI,3622
-llm_utils/chat_format/__init__.py,sha256=8dBIUqFJvkgQYedxBtcyxt-4tt8JxAKVap2JlTXmgaM,737
-llm_utils/chat_format/display.py,sha256=3jKDm4OTrvytK1qBhSOjRLltUIObHsYFdBLgm8SVDE8,14159
+llm_utils/chat_format/__init__.py,sha256=MCNT8o-BZWmoOFE5VLyhJJOqHg8lJGqHXEKSXU08fK0,775
+llm_utils/chat_format/display.py,sha256=HiAOAC8FY7956gNuwE7rxii1MCCebn0avbXi1iIcDSc,17178
 llm_utils/chat_format/transform.py,sha256=eU0c3PdAHCNLuGP1UqPwln0B34Lv3bt_uV9v9BrlCN4,5402
 llm_utils/chat_format/utils.py,sha256=xTxN4HrLHcRO2PfCTR43nH1M5zCa7v0kTTdzAcGkZg0,1229
-llm_utils/lm/__init__.py,sha256=znjUTzke2tmCRWkR46sbOQPcRNe5oEbLo5zqg6Vxud0,632
+llm_utils/lm/__init__.py,sha256=FBe8wVNWDMpvJ2kQYedJ3HH5L2BCAZBQVE0zEjND0Vo,729
 llm_utils/lm/base_prompt_builder.py,sha256=OLqyxbA8QeYIVFzB9EqxUiE_P2p4_MD_Lq4WSwxFtKU,12136
-llm_utils/lm/llm_as_a_judge.py,sha256=LwqzlIMSBbpv6A2Qq8-fhVO2CGO7_BtU6j0PXoIWFOA,14022
-llm_utils/lm/llm_task.py,sha256=gawOtoP-LOH-8iaUI_2-TXvhFAVuj2fWGxeQZ1xytAo,25288
+llm_utils/lm/llm.py,sha256=uk45JhVcWDMaqezn9Yn_K5hehFSmQ4txU901fn_PcQg,16262
+llm_utils/lm/llm_signature.py,sha256=SP72cWXaVGcZs3m2V361DcLk_St7aYJamNapUiFBB6Q,1242
 llm_utils/lm/lm_base.py,sha256=pqbHZOdR7yUMpvwt8uBG1dZnt76SY_Wk8BkXQQ-mpWs,9557
-llm_utils/lm/openai_memoize.py,sha256=KToCcB_rhyrULxolnwMfQgl5GNrAeykePxuLS4hBjtc,3442
-llm_utils/lm/signature.py,sha256=s3Zjxjs6AU97jbz1LZ2BTGw-F9aFCF3G346gSMtyEpE,10370
-llm_utils/lm/utils.py,sha256=25oOznZhbBWfen1-X1PXQfO09kQZgP5V9CDuqLrf_ZU,12440
+llm_utils/lm/mixins.py,sha256=Sn5KyPKGCT_HVJmmosmy3XSlZ0_k5Kds0VvSJqeUDpI,13695
+llm_utils/lm/openai_memoize.py,sha256=PDs3YCXKgHXaHlegkhouzPtf2Gom_o7pvzChCT-NQyQ,3870
+llm_utils/lm/signature.py,sha256=16QOHnGc-p7H8rR3j1dPg8AokdV_rEGUYCGGkIHIghE,10240
+llm_utils/lm/utils.py,sha256=oiJ50b8WV6oktnW4BByr1gRaGc55VJeF3IyhHqoofp4,12193
 llm_utils/lm/async_lm/__init__.py,sha256=PUBbCuf5u6-0GBUu-2PI6YAguzsyXj-LPkU6vccqT6E,121
 llm_utils/lm/async_lm/_utils.py,sha256=P1-pUDf_0pDmo8WTIi43t5ARlyGA1RIJfpAhz-gfA5g,6105
 llm_utils/lm/async_lm/async_llm_task.py,sha256=-BVOk18ZD8eC2obTLgiPq39f2PP3cji17Ku-Gb7c7Xo,18683
@@ -26,8 +27,8 @@ llm_utils/vector_cache/cli.py,sha256=DMXTj8nZ2_LRjprbYPb4uzq04qZtOfBbmblmaqDcCuM
 llm_utils/vector_cache/core.py,sha256=J8ocRX9sBfzboQkf5vFF2cx0SK-nftmKWJUa91WUBy8,31134
 llm_utils/vector_cache/types.py,sha256=ru8qmUZ8_lNd3_oYpjCMtpXTsqmwsSBe56Z4hTWm3xI,435
 llm_utils/vector_cache/utils.py,sha256=dwbbXlRrARrpmS4YqSlYQqrTURg0UWe8XvaAWcX05MM,1458
-speedy_utils/__init__.py,sha256=QBvGIbrC5yczQwh4T8iu9KQx6w9u-v_JdoQfA67hLUg,5780
-speedy_utils/all.py,sha256=t-HKzDmhF1MTFnmq7xRnPs5nFG_aZaLH9Ua0RM6nQ9Y,4855
+speedy_utils/__init__.py,sha256=LFV2La5TaYkXbe5xVQ9xiDqsjcjcF0QUyg58jI8UMfI,6081
+speedy_utils/all.py,sha256=gXXRlBLvU8AON7XqO6iFQ8LCIQEIcP_2CDumd_U1ppI,5171
 speedy_utils/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 speedy_utils/common/clock.py,sha256=3n4FkCW0dz46O8By09V5Pve1DSMgpLDRbWEVRryryeQ,7423
 speedy_utils/common/function_decorator.py,sha256=BspJ0YuGL6elS7lWBAgELZ-sCfED_1N2P5fgH-fCRUQ,2132
@@ -36,16 +37,16 @@ speedy_utils/common/notebook_utils.py,sha256=-97kehJ_Gg3TzDLubsLIYJcykqX1NXhbvBO
 speedy_utils/common/patcher.py,sha256=VCmdxyTF87qroggQkQklRPhAOPJbeBqhcJoTsLcDxNw,2303
 speedy_utils/common/report_manager.py,sha256=eBiw5KY6bWUhwki3B4lK5o8bFsp7L5x28X9GCI-Sd1w,3899
 speedy_utils/common/utils_cache.py,sha256=NCwILnhsK86sDPkkriDTCyuM-qUKFxYOo1Piww1ED0g,22381
-speedy_utils/common/utils_io.py,sha256=-RkQjYGa3zVqpgVInsdp8dbS5oLwdJdUsRz1XIUSJzg,14257
-speedy_utils/common/utils_misc.py,sha256=cdEuBBpiB1xpuzj0UBDHDuTIerqsMIw37ENq6EXliOw,1795
+speedy_utils/common/utils_io.py,sha256=E7mbxB_OpLvNWoFM2Qpxi1jaD8VwF-tvNOpGbf7swuU,14849
+speedy_utils/common/utils_misc.py,sha256=yYlyP0eXQuapY1dn5O8-UDePPq5bb6FxKFjb1kfZy5o,2354
 speedy_utils/common/utils_print.py,sha256=syRrnSFtguxrV-elx6DDVcSGu4Qy7D_xVNZhPwbUY4A,4864
 speedy_utils/multi_worker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 speedy_utils/multi_worker/process.py,sha256=RGGGnbZXCbEbdmxFVmnNfyccClAlflzRPE0d1C3CeeE,11385
-speedy_utils/multi_worker/thread.py,sha256=UniMl8mw-Xw1y3aU9bKGMtBSlQj05QhFouWb5aVkATI,21679
+speedy_utils/multi_worker/thread.py,sha256=bRjxUHkBjbXHQ2KSsf-Zao28zbSId-8mqMFHwSG1l1s,25206
 speedy_utils/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 speedy_utils/scripts/mpython.py,sha256=IvywP7Y0_V6tWfMP-4MjPvN5_KfxWF21xaLJsCIayCk,3821
 speedy_utils/scripts/openapi_client_codegen.py,sha256=f2125S_q0PILgH5dyzoKRz7pIvNEjCkzpi4Q4pPFRZE,9683
-speedy_utils-1.1.23.dist-info/METADATA,sha256=xmQbqlIBS8fHw9ZZFG2kLftUiZX37cCt0hMmFc7putk,8028
-speedy_utils-1.1.23.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-speedy_utils-1.1.23.dist-info/entry_points.txt,sha256=1rrFMfqvaMUE9hvwGiD6vnVh98kmgy0TARBj-v0Lfhs,244
-speedy_utils-1.1.23.dist-info/RECORD,,
+speedy_utils-1.1.24.dist-info/METADATA,sha256=3KOAmdRLEkW8wXkjAIZwvurxWeTKGcNyRg-oHhDRpBA,8028
+speedy_utils-1.1.24.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+speedy_utils-1.1.24.dist-info/entry_points.txt,sha256=1rrFMfqvaMUE9hvwGiD6vnVh98kmgy0TARBj-v0Lfhs,244
+speedy_utils-1.1.24.dist-info/RECORD,,