speedy-utils 1.1.16__py3-none-any.whl → 1.1.18__py3-none-any.whl

speedy_utils/common/utils_io.py

@@ -87,9 +87,236 @@ def load_json_or_pickle(fname: str, counter=0) -> Any:
             raise ValueError(f"Error {e} while loading {fname}") from e
 
 
-def load_jsonl(path):
-    lines = open(path, encoding="utf-8").read().splitlines()
-    return [json.loads(line) for line in lines]
+import os, io, json, gzip, bz2, lzma, warnings
+from typing import Iterable, Union, IO, Any, Optional, cast
+
+try:
+    import orjson  # type: ignore[import-not-found]  # fastest JSON parser when available
+except Exception:
+    orjson = None
+
+try:
+    import zstandard as zstd  # type: ignore[import-not-found]  # optional .zst support
+except Exception:
+    zstd = None
+
+
+def fast_load_jsonl(
+    path_or_file: Union[str, os.PathLike, IO],
+    *,
+    progress: bool = False,
+    desc: str = "Reading JSONL",
+    use_orjson: bool = True,
+    encoding: str = "utf-8",
+    errors: str = "strict",
+    on_error: str = "raise",   # 'raise' | 'warn' | 'skip'
+    skip_empty: bool = True,
+    max_lines: Optional[int] = None,
+    use_multiworker: bool = True,
+    multiworker_threshold: int = 50000,
+    workers: Optional[int] = None,
+) -> Iterable[Any]:
+    """
+    Lazily iterate objects from a JSON Lines file.
+
+    - Streams line-by-line (constant memory).
+    - Optional tqdm progress over bytes (compressed size if gz/bz2/xz/zst).
+    - Auto-detects compression by extension: .gz, .bz2, .xz/.lzma, .zst/.zstd.
+    - Uses orjson if available (use_orjson=True), falls back to json.
+    - Automatically uses multi-worker processing for large files (>50k lines).
+
+    Args:
+        path_or_file: Path-like or file-like object. File-like can be binary or text.
+        progress: Show a tqdm progress bar (bytes). Requires `tqdm` if True.
+        desc: tqdm description if progress=True.
+        use_orjson: Prefer orjson for speed if installed.
+        encoding, errors: Used when decoding text or when falling back to `json`.
+        on_error: What to do on a malformed line: 'raise', 'warn', or 'skip'.
+        skip_empty: Skip blank/whitespace-only lines.
+        max_lines: Stop after reading this many lines (useful for sampling).
+        use_multiworker: Enable multi-worker processing for large files.
+        multiworker_threshold: Line count threshold to trigger multi-worker processing.
+        workers: Number of worker threads (defaults to CPU count).
+
+    Yields:
+        Parsed Python objects per line.
+    """
+    def _open_auto(pth_or_f) -> IO[Any]:
+        if hasattr(pth_or_f, "read"):
+            # ensure binary buffer for consistent byte-length progress
+            fobj = pth_or_f
+            # If it's text, wrap it to binary via encoding; else just return
+            if isinstance(fobj, io.TextIOBase):
+                # TextIO -> re-encode to bytes on the fly
+                return io.BufferedReader(io.BytesIO(fobj.read().encode(encoding, errors)))
+            return pth_or_f  # assume binary
+        s = str(pth_or_f).lower()
+        if s.endswith(".gz"):
+            return gzip.open(pth_or_f, "rb")  # type: ignore
+        if s.endswith(".bz2"):
+            return bz2.open(pth_or_f, "rb")  # type: ignore
+        if s.endswith((".xz", ".lzma")):
+            return lzma.open(pth_or_f, "rb")  # type: ignore
+        if s.endswith((".zst", ".zstd")) and zstd is not None:
+            fh = open(pth_or_f, "rb")
+            dctx = zstd.ZstdDecompressor()
+            stream = dctx.stream_reader(fh)
+            return io.BufferedReader(stream)  # type: ignore
+        # plain
+        return open(pth_or_f, "rb", buffering=1024 * 1024)
+
+    def _count_lines_fast(file_path: Union[str, os.PathLike]) -> int:
+        """Quickly count lines in a file, handling compression."""
+        try:
+            f = _open_auto(file_path)
+            count = 0
+            for _ in f:
+                count += 1
+            f.close()
+            return count
+        except Exception:
+            # If we can't count lines, assume it's small
+            return 0
+
+    def _process_chunk(chunk_lines: list[bytes]) -> list[Any]:
+        """Process a chunk of lines and return parsed objects."""
+        results = []
+        for line_bytes in chunk_lines:
+            if skip_empty and not line_bytes.strip():
+                continue
+            line_bytes = line_bytes.rstrip(b"\r\n")
+            try:
+                if use_orjson and orjson is not None:
+                    obj = orjson.loads(line_bytes)
+                else:
+                    obj = json.loads(line_bytes.decode(encoding, errors))
+                results.append(obj)
+            except Exception as e:
+                if on_error == "raise":
+                    raise
+                if on_error == "warn":
+                    warnings.warn(f"Skipping malformed line: {e}")
+                # 'skip' and 'warn' both skip the line
+                continue
+        return results
+
+    # Check if we should use multi-worker processing
+    should_use_multiworker = (
+        use_multiworker 
+        and not hasattr(path_or_file, "read")  # Only for file paths, not file objects
+        and max_lines is None  # Don't use multiworker if we're limiting lines
+    )
+    
+    if should_use_multiworker:
+        line_count = _count_lines_fast(cast(Union[str, os.PathLike], path_or_file))
+        if line_count > multiworker_threshold:
+            # Use multi-worker processing
+            from ..multi_worker.thread import multi_thread
+            
+            # Read all lines into chunks
+            f = _open_auto(path_or_file)
+            all_lines = list(f)
+            f.close()
+            
+            # Split into chunks for workers
+            num_workers = workers or os.cpu_count() or 4
+            chunk_size = max(len(all_lines) // num_workers, 1000)
+            chunks = []
+            for i in range(0, len(all_lines), chunk_size):
+                chunks.append(all_lines[i:i + chunk_size])
+            
+            # Process chunks in parallel
+            if progress:
+                print(f"Processing {line_count} lines with {num_workers} workers...")
+            
+            chunk_results = multi_thread(_process_chunk, chunks, workers=num_workers, progress=progress)
+            
+            # Flatten results and yield
+            for chunk_result in chunk_results:
+                for obj in chunk_result:
+                    yield obj
+            return
+
+    # Single-threaded processing (original logic)
+
+    f = _open_auto(path_or_file)
+
+    pbar = None
+    if progress:
+        try:
+            from tqdm import tqdm  # type: ignore
+        except Exception as e:
+            raise ImportError("tqdm is required when progress=True") from e
+        total = None
+        if not hasattr(path_or_file, "read"):
+            try:
+                path_for_size = cast(Union[str, os.PathLike], path_or_file)
+                total = os.path.getsize(path_for_size)  # compressed size if any
+            except Exception:
+                total = None
+        pbar = tqdm(total=total, unit="B", unit_scale=True, desc=desc)
+
+    line_no = 0
+    try:
+        for raw_line in f:
+            line_no += 1
+            if pbar is not None:
+                # raw_line is bytes here; if not, compute byte length
+                nbytes = len(raw_line) if isinstance(raw_line, (bytes, bytearray)) else len(str(raw_line).encode(encoding, errors))
+                pbar.update(nbytes)
+
+            # Normalize to bytes -> str only if needed
+            if isinstance(raw_line, (bytes, bytearray)):
+                if skip_empty and not raw_line.strip():
+                    if max_lines and line_no >= max_lines:
+                        break
+                    continue
+                line_bytes = raw_line.rstrip(b"\r\n")
+                # Parse
+                try:
+                    if use_orjson and orjson is not None:
+                        obj = orjson.loads(line_bytes)
+                    else:
+                        obj = json.loads(line_bytes.decode(encoding, errors))
+                except Exception as e:
+                    if on_error == "raise":
+                        raise
+                    if on_error == "warn":
+                        warnings.warn(f"Skipping malformed line {line_no}: {e}")
+                    # 'skip' and 'warn' both skip the line
+                    if max_lines and line_no >= max_lines:
+                        break
+                    continue
+            else:
+                # Text line path (unlikely)
+                if skip_empty and not raw_line.strip():
+                    if max_lines and line_no >= max_lines:
+                        break
+                    continue
+                try:
+                    obj = json.loads(raw_line)
+                except Exception as e:
+                    if on_error == "raise":
+                        raise
+                    if on_error == "warn":
+                        warnings.warn(f"Skipping malformed line {line_no}: {e}")
+                    if max_lines and line_no >= max_lines:
+                        break
+                    continue
+
+            yield obj
+            if max_lines and line_no >= max_lines:
+                break
+    finally:
+        if pbar is not None:
+            pbar.close()
+        # Close only if we opened it (i.e., not an external stream)
+        if not hasattr(path_or_file, "read"):
+            try:
+                f.close()
+            except Exception:
+                pass
+
 
 
 def load_by_ext(fname: Union[str, list[str]], do_memoize: bool = False) -> Any:
@@ -124,7 +351,7 @@ def load_by_ext(fname: Union[str, list[str]], do_memoize: bool = False) -> Any:
 
         def load_default(path: str) -> Any:
             if path.endswith(".jsonl"):
-                return load_jsonl(path)
+                return list(fast_load_jsonl(path, progress=True))
             elif path.endswith(".json"):
                 try:
                     return load_json_or_pickle(path)
@@ -159,14 +386,13 @@ def jdumps(obj, ensure_ascii=False, indent=2, **kwargs):
     return json.dumps(obj, ensure_ascii=ensure_ascii, indent=indent, **kwargs)
 
 
-
+load_jsonl = lambda path: list(fast_load_jsonl(path))
 
 __all__ = [
     "dump_json_or_pickle",
     "dump_jsonl",
     "load_by_ext",
     "load_json_or_pickle",
-    "load_jsonl",
     "jdumps",
     "jloads",
 ]

speedy_utils/multi_worker/process.py

@@ -1,203 +1,134 @@
-import multiprocessing
-import os
-import traceback
-from collections.abc import Callable, Iterable, Iterator
-from concurrent.futures import ProcessPoolExecutor, as_completed
-from itertools import islice
-from typing import Any, TypeVar, Union, cast
+# ray_multi_process.py
+import time, os, pickle, uuid, datetime
+from pathlib import Path
+from typing import Any, Callable
+from tqdm import tqdm
+import ray
+from fastcore.parallel import parallel
+
+# ─── cache helpers ──────────────────────────────────────────
+
+def _build_cache_dir(func: Callable, items: list[Any]) -> Path:
+    """Build cache dir with function name + timestamp."""
+    func_name = getattr(func, "__name__", "func")
+    now = datetime.datetime.now()
+    stamp = now.strftime("%m%d_%Hh%Mm%Ss")
+    run_id = f"{func_name}_{stamp}_{uuid.uuid4().hex[:6]}"
+    path = Path(".cache") / run_id
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+def wrap_dump(func: Callable, cache_dir: Path | None):
+    """Wrap a function so results are dumped to .pkl when cache_dir is set."""
+    if cache_dir is None:
+        return func
+
+    def wrapped(x, *args, **kwargs):
+        res = func(x, *args, **kwargs)
+        p = cache_dir / f"{uuid.uuid4().hex}.pkl"
+        with open(p, "wb") as fh:
+            pickle.dump(res, fh)
+        return str(p)
+    return wrapped
+
+# ─── ray management ─────────────────────────────────────────
+
+RAY_WORKER = None
+
+def ensure_ray(workers: int, pbar: tqdm | None = None):
+    """Initialize or reinitialize Ray with a given worker count, log to bar postfix."""
+    global RAY_WORKER
+    if not ray.is_initialized() or RAY_WORKER != workers:
+        if ray.is_initialized() and pbar:
+            pbar.set_postfix_str(f"Restarting Ray {workers} workers")
+            ray.shutdown()
+        t0 = time.time()
+        ray.init(num_cpus=workers, ignore_reinit_error=True)
+        took = time.time() - t0
+        if pbar:
+            pbar.set_postfix_str(f"ray.init {workers} took {took:.2f}s")
+        RAY_WORKER = workers
+
+# ─── main API ───────────────────────────────────────────────
+from typing import Literal
 
-T = TypeVar("T")
-
-if hasattr(multiprocessing, "set_start_method"):
-    try:
-        multiprocessing.set_start_method("spawn", force=True)
-    except RuntimeError:
-        pass
-
-try:
-    from tqdm import tqdm
-except ImportError:  # pragma: no cover
-    tqdm = None  # type: ignore[assignment]
-
-
-# ──── internal helpers ────────────────────────────────────────────────────
-
-
-def _group_iter(src: Iterable[Any], size: int) -> Iterable[list[Any]]:
-    "Yield *size*-sized chunks from *src*."
-    it = iter(src)
-    while chunk := list(islice(it, size)):
-        yield chunk
-
-
-def _short_tb() -> str:
-    tb = "".join(traceback.format_exc())
-    return "\n".join(ln for ln in tb.splitlines() if "multi_process" not in ln)
-
-
-def _safe_call(func: Callable, obj, fixed):
-    try:
-        return func(obj, **fixed)
-    except Exception as exc:
-        func_name = getattr(func, "__name__", str(func))
-        raise RuntimeError(
-            f"{func_name}({obj!r}) failed: {exc}\n{_short_tb()}"
-        ) from exc
-
-
-def _worker_process(
-    func: Callable, item_batch: Any, fixed_kwargs: dict, batch_size: int
-):
-    """Worker function executed in each process."""
-    if batch_size > 1:
-        results = []
-        for itm in item_batch:
-            try:
-                results.append(_safe_call(func, itm, fixed_kwargs))
-            except Exception:
-                results.append(None)
-        return results
-    return _safe_call(func, item_batch, fixed_kwargs)
-
-
-# ──── public API ──────────────────────────────────────────────────────────
 def multi_process(
     func: Callable[[Any], Any],
-    inputs: Iterable[Any],
+    items: list[Any] | None = None,
     *,
-    workers: Union[int, None] = None,
-    batch: int = 1,
-    ordered: bool = True,
-    progress: bool = False,
-    inflight: Union[int, None] = None,
-    timeout: Union[float, None] = None,
-    stop_on_error: bool = True,
-    process_update_interval=10,
-    for_loop: bool = False,
-    **fixed_kwargs,
+    inputs: list[Any] | None = None,
+    workers: int | None = None,
+    lazy_output: bool = False,
+    progress: bool = True,
+    # backend: str = "ray",   # "seq", "ray", or "fastcore"
+    backend: Literal["seq", "ray", "mp", "threadpool"] = "ray",
+    # Additional optional knobs (accepted for compatibility)
+    batch: int | None = None,
+    ordered: bool | None = None,
+    process_update_interval: int | None = None,
+    stop_on_error: bool | None = None,
+    **func_kwargs: Any,
 ) -> list[Any]:
     """
-    Simple multi‑processing parallel map that returns a *list*.
-
-    Parameters
-    ----------
-    func          – target callable executed in separate processes, must be of the form f(obj, ...).
-    inputs        – iterable with the objects.
-    workers       – process pool size (defaults to :pyfunc:`os.cpu_count()`).
-    batch         – package *batch* inputs into one call to reduce IPC overhead.
-    ordered       – keep original order; if ``False`` results stream as finished.
-    progress      – show a tqdm bar (requires *tqdm*).
-    inflight      – max logical items concurrently submitted
-                    *(default: ``workers × 4``)*.
-    timeout       – overall timeout for the mapping (seconds).
-    stop_on_error – raise immediately on first exception (default) or
-                    substitute failing result with ``None``.
-    **fixed_kwargs – static keyword args forwarded to every ``func()`` call.
+    Multi-process map with selectable backend.
+
+    backend:
+        - "seq": run sequentially
+        - "ray": run in parallel with Ray
+        - "fastcore": run in parallel with fastcore.parallel
+
+    If lazy_output=True, every result is saved to .pkl and
+    the returned list contains file paths.
     """
-    if for_loop:
-        ret = []
-        for arg in inputs:
-            ret.append(func(arg, **fixed_kwargs))
-        return ret
+
+    # unify items
+    if items is None and inputs is not None:
+        items = list(inputs)
+    if items is None:
+        raise ValueError("'items' or 'inputs' must be provided")
 
     if workers is None:
         workers = os.cpu_count() or 1
-    if inflight is None:
-        inflight = workers * 4
-    if batch < 1:
-        raise ValueError("batch must be ≥ 1")
-
-    try:
-        n_inputs = len(inputs)  # type: ignore[arg-type]
-    except Exception:
-        n_inputs = None
-
-    src_iter: Iterator[Any] = iter(inputs)
-    if batch > 1:
-        src_iter = cast(Iterator[Any], _group_iter(src_iter, batch))
-
-    logical_total = n_inputs
-    bar = None
-    last_bar = 0
-    if progress and tqdm is not None and logical_total is not None:
-        bar = tqdm(
-            total=logical_total,
-            ncols=80,
-            colour="green",
-            bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt}"
-            " [{elapsed}<{remaining}, {rate_fmt}{postfix}]",
-        )
-
-    if ordered and logical_total is not None:
-        results: list[Any] = [None] * logical_total
-    else:
-        results = []
-
-    completed = 0
-    next_idx = 0
-
-    with ProcessPoolExecutor(max_workers=workers) as pool:
-        futures = set()
-
-        for _ in range(min(inflight, workers)):
-            try:
-                arg = next(src_iter)
-            except StopIteration:
-                break
-            fut = pool.submit(_worker_process, func, arg, fixed_kwargs, batch)
-            fut.idx = next_idx  # type: ignore[attr-defined]
-            futures.add(fut)
-            next_idx += len(arg) if batch > 1 else 1
-
-        while futures:
-            for fut in as_completed(futures, timeout=timeout):
-                futures.remove(fut)
-                idx = fut.idx  # type: ignore[attr-defined]
-                try:
-                    res = fut.result()
-                except Exception:
-                    if stop_on_error:
-                        raise
-                    num_items = batch if batch > 1 else 1
-                    res = [None] * num_items if batch > 1 else None
-
-                out_items = res if batch > 1 else [res]
-                if out_items is None:
-                    out_items = []
-
-                if ordered and logical_total is not None:
-                    if isinstance(out_items, list) and len(out_items) > 0:
-                        for i, item in enumerate(out_items):
-                            if idx + i < len(results):
-                                results[idx + i] = item
-                else:
-                    if isinstance(out_items, list):
-                        results.extend(out_items)
-
-                completed += len(out_items)
-
-                if bar and completed - last_bar >= process_update_interval:
-                    bar.update(completed - last_bar)
-                    last_bar = completed
-
-                try:
-                    while next_idx - completed < inflight:
-                        arg = next(src_iter)
-                        fut2 = pool.submit(
-                            _worker_process, func, arg, fixed_kwargs, batch
-                        )
-                        fut2.idx = next_idx  # type: ignore[attr-defined]
-                        futures.add(fut2)
-                        next_idx += len(arg) if batch > 1 else 1
-                except StopIteration:
-                    pass
-                break
-
-    if bar:
-        bar.update(completed - last_bar)
-        bar.close()
-
-    return results
-
-
-__all__ = ["multi_process"]
+
+    # build cache dir + wrap func
+    cache_dir = _build_cache_dir(func, items) if lazy_output else None
+    f_wrapped = wrap_dump(func, cache_dir)
+
+    total = len(items)
+    with tqdm(total=total, desc=f"multi_process [{backend}]", disable=not progress) as pbar:
+
+        # ---- sequential backend ----
+        if backend == "seq":
+            pbar.set_postfix_str("backend=seq")
+            results = []
+            for x in items:
+                results.append(f_wrapped(x, **func_kwargs))
+                pbar.update(1)
+            return results
+
+        # ---- ray backend ----
+        if backend == "ray":
+            pbar.set_postfix_str("backend=ray")
+            ensure_ray(workers, pbar)
+
+            @ray.remote
+            def _task(x):
+                return f_wrapped(x, **func_kwargs)
+
+            refs = [_task.remote(x) for x in items]
+
+            results = []
+            for r in refs:
+                results.append(ray.get(r))
+                pbar.update(1)
+            return results
+
+        # ---- fastcore backend ----
+        if backend == "mp":
+            results = parallel(f_wrapped, items, n_workers=workers, progress=progress, threadpool=False)
+            return list(results)
+        if backend == "threadpool":
+            results = parallel(f_wrapped, items, n_workers=workers, progress=progress, threadpool=True)
+            return list(results)
+
+        raise ValueError(f"Unsupported backend: {backend!r}")

{speedy_utils-1.1.16.dist-info → speedy_utils-1.1.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: speedy-utils
-Version: 1.1.16
+Version: 1.1.18
 Summary: Fast and easy-to-use package for data science
 Author: AnhVTH
 Author-email: anhvth.226@gmail.com
@@ -12,6 +12,7 @@ Classifier: Programming Language :: Python :: 3.10
 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-Dist: bump2version
 Requires-Dist: cachetools
 Requires-Dist: debugpy

{speedy_utils-1.1.16.dist-info → speedy_utils-1.1.18.dist-info}/RECORD

@@ -1,16 +1,20 @@
-llm_utils/__init__.py,sha256=Ap_X4yvwCroQvTveBx7_LkGMpVnw_rBoY2NrqAI-SQ4,732
+llm_utils/__init__.py,sha256=KjgorCpl2YbAGaqaOvFDDlE7V2GUzxFx_Xyz5ROnWZc,916
 llm_utils/chat_format/__init__.py,sha256=8dBIUqFJvkgQYedxBtcyxt-4tt8JxAKVap2JlTXmgaM,737
-llm_utils/chat_format/display.py,sha256=M-__JpcJSqjqeP4LiW7-yF8fVL37yUEUdaNC4VEgIo8,10181
+llm_utils/chat_format/display.py,sha256=3jKDm4OTrvytK1qBhSOjRLltUIObHsYFdBLgm8SVDE8,14159
 llm_utils/chat_format/transform.py,sha256=eU0c3PdAHCNLuGP1UqPwln0B34Lv3bt_uV9v9BrlCN4,5402
 llm_utils/chat_format/utils.py,sha256=xTxN4HrLHcRO2PfCTR43nH1M5zCa7v0kTTdzAcGkZg0,1229
 llm_utils/group_messages.py,sha256=Oe2tlhg-zRodG1-hodYebddrR77j9UdE05LzJw0EvYI,3622
-llm_utils/lm/__init__.py,sha256=rX36_MsnekM5GHwWS56XELbm4W5x2TDwnPERDTfo0eU,194
+llm_utils/lm/__init__.py,sha256=totIZnq1P8eNlfVco0OfdGdTNt1-wSXDSRReRRzYYxw,319
 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=iXSTbf-KekXncVVnic-v4dTq5HBDjbyLwhgo0Y-wp7Q,19167
-llm_utils/lm/async_lm/async_lm.py,sha256=slGOUXFeWAy3Ak7Xj7Z4JNqCgAUBo21Hjg3RD75Ul2Q,13396
-llm_utils/lm/async_lm/async_lm_base.py,sha256=Qh9Bx_S-FboO7huUi6TqP3KiTVHDH0C-Tfbd_UJC7Cc,8122
+llm_utils/lm/async_lm/async_llm_task.py,sha256=A5WLIN3v-zpl-sJGiykyo8wOCYEpA8ja70MJcn5t7O4,18668
+llm_utils/lm/async_lm/async_lm.py,sha256=e3o9cyMbkVz_jQDTjJv2ybET_5mY012zdZGjNwi4Qk4,13719
+llm_utils/lm/async_lm/async_lm_base.py,sha256=iJgtzI6pVJzWtlXGqVLwgCIb-FzZAa3E5xW8yhyHUmM,8426
 llm_utils/lm/async_lm/lm_specific.py,sha256=KmqdCm3SJ5MqN-dRJd6S5tq5-ve1X2eNWf2CMFtc_3s,3926
+llm_utils/lm/base_prompt_builder.py,sha256=OLqyxbA8QeYIVFzB9EqxUiE_P2p4_MD_Lq4WSwxFtKU,12136
+llm_utils/lm/llm_task.py,sha256=K5c27iYM9etAbdDM1WiO3-GjTvl1dkzt2sIaW3N1YA0,15483
+llm_utils/lm/lm.py,sha256=8TaLuU7naPQbOFmiS2NQyWVLG0jUUzRRBQsR0In7GVo,7249
+llm_utils/lm/lm_base.py,sha256=pqbHZOdR7yUMpvwt8uBG1dZnt76SY_Wk8BkXQQ-mpWs,9557
 llm_utils/lm/openai_memoize.py,sha256=DdMl31cV9AqLlkARajZrqAKCyhvH8JQk2SAHMSzO3mk,3024
 llm_utils/lm/utils.py,sha256=a0KJj8vjT2fHKb7GKGNJjJHhKLThwpxIL7vnV9Fr3ZY,4584
 llm_utils/scripts/README.md,sha256=yuOLnLa2od2jp4wVy3rV0rESeiV3o8zol5MNMsZx0DY,999
@@ -18,7 +22,7 @@ llm_utils/scripts/vllm_load_balancer.py,sha256=TT5Ypq7gUcl52gRFp--ORFFjzhfGlcaX2
 llm_utils/scripts/vllm_serve.py,sha256=gJ0-y4kybMfSt8qzye1pJqGMY3x9JLRi6Tu7RjJMnss,14771
 llm_utils/vector_cache/__init__.py,sha256=i1KQuC4OhPewYpFl9X6HlWFBuASCTx2qgGizhpZhmn0,862
 llm_utils/vector_cache/cli.py,sha256=DMXTj8nZ2_LRjprbYPb4uzq04qZtOfBbmblmaqDcCuM,6251
-llm_utils/vector_cache/core.py,sha256=rsfZbaUk8ZbAKHcStbmxeZbk8LfTvO_prmqof-WVvC0,22663
+llm_utils/vector_cache/core.py,sha256=P0VopzMmfnGaYTTEiccXprsyjruje3QT0_AFXF1lZC0,33582
 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=nJpUb5Oa3STDbqPSiWXoI-IvKntyRYzYxkYW4GM2i_Q,5740
@@ -28,18 +32,19 @@ speedy_utils/common/clock.py,sha256=3n4FkCW0dz46O8By09V5Pve1DSMgpLDRbWEVRryryeQ,
 speedy_utils/common/function_decorator.py,sha256=BspJ0YuGL6elS7lWBAgELZ-sCfED_1N2P5fgH-fCRUQ,2132
 speedy_utils/common/logger.py,sha256=a2iZx0eWyfi2-2X_H2QmfuA3tfR7_XSM7Nd0GdUnUOs,6435
 speedy_utils/common/notebook_utils.py,sha256=-97kehJ_Gg3TzDLubsLIYJcykqX1NXhbvBO6nniZSYM,2063
+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=0cQJm0nnD9755pWMdAkhDn2qIbGvJMTMUl2gibkX05E,22376
-speedy_utils/common/utils_io.py,sha256=76ZVgJwgjOznq5L_i2oyWuBnuwymjcktqSvB8VWTKsc,5250
+speedy_utils/common/utils_cache.py,sha256=BCYbtu8lWkLjrPRQnOWHr41IBOLrpOvXIOI4Sg389nc,22430
+speedy_utils/common/utils_io.py,sha256=gv5YN4tYvxsUcCXwaY_hv2g6a9HNltxBC0kNE0iZLak,14284
 speedy_utils/common/utils_misc.py,sha256=cdEuBBpiB1xpuzj0UBDHDuTIerqsMIw37ENq6EXliOw,1795
 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=MJ5njqjY9nMo-Z1oXMbzkppuYVJCcCtFsLo8lbCh5zs,6849
+speedy_utils/multi_worker/process.py,sha256=LmNfV8tfdsf6PFTNzu12C_QWNfEUhgi1MeAJGeMTs1k,4738
 speedy_utils/multi_worker/thread.py,sha256=f02VjJV8nudg0eA_AcfPEX7tHY4-czesuzthKZs_Hdc,16351
 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.16.dist-info/METADATA,sha256=euFPmJ3wunhuo_2aUpUGxfV-KlAjF8wFaEzHJqkQ6dM,7483
-speedy_utils-1.1.16.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-speedy_utils-1.1.16.dist-info/entry_points.txt,sha256=T1t85jwx8fK6m5msdkBGIXH5R5Kd0zSL0S6erXERPzg,237
-speedy_utils-1.1.16.dist-info/RECORD,,
+speedy_utils-1.1.18.dist-info/METADATA,sha256=dqAnyKYkHVF3HHvzhopXo6huQE16OhFMuGcQUwH6xE0,7534
+speedy_utils-1.1.18.dist-info/WHEEL,sha256=M5asmiAlL6HEcOq52Yi5mmk9KmTVjY2RDPtO4p9DMrc,88
+speedy_utils-1.1.18.dist-info/entry_points.txt,sha256=T1t85jwx8fK6m5msdkBGIXH5R5Kd0zSL0S6erXERPzg,237
+speedy_utils-1.1.18.dist-info/RECORD,,