speedy-utils 0.1.28__py3-none-any.whl → 1.0.0__py3-none-any.whl

llm_utils/scripts/vllm_serve.py

@@ -0,0 +1,482 @@
+""" "
+USAGE:
+Serve models and LoRAs with vLLM:
+
+Serve a LoRA model:
+svllm serve --lora LORA_NAME LORA_PATH --gpus GPU_GROUPS
+
+Serve a base model:
+svllm serve --model MODEL_NAME --gpus GPU_GROUPS
+
+Add a LoRA to a served model:
+svllm add-lora --lora LORA_NAME LORA_PATH --host_port host:port (if add then the port must be specify)
+"""
+
+from glob import glob
+import os
+import subprocess
+import time
+from typing import List, Literal, Optional
+from fastcore.script import call_parse
+from loguru import logger
+import argparse
+import requests
+import openai
+
+
+LORA_DIR = os.environ.get("LORA_DIR", "/loras")
+LORA_DIR = os.path.abspath(LORA_DIR)
+HF_HOME = os.environ.get("HF_HOME", os.path.expanduser("~/.cache/huggingface"))
+logger.info(f"LORA_DIR: {LORA_DIR}")
+
+
+def model_list(host_port, api_key="abc"):
+    client = openai.OpenAI(base_url=f"http://{host_port}/v1", api_key=api_key)
+    models = client.models.list()
+    for model in models:
+        print(f"Model ID: {model.id}")
+
+
+def kill_existing_vllm(vllm_binary: Optional[str] = None) -> None:
+    """Kill selected vLLM processes using fzf."""
+    if not vllm_binary:
+        vllm_binary = get_vllm()
+
+    # List running vLLM processes
+    result = subprocess.run(
+        f"ps aux | grep {vllm_binary} | grep -v grep",
+        shell=True,
+        capture_output=True,
+        text=True,
+    )
+    processes = result.stdout.strip().split("\n")
+
+    if not processes or processes == [""]:
+        print("No running vLLM processes found.")
+        return
+
+    # Use fzf to select processes to kill
+    fzf = subprocess.Popen(
+        ["fzf", "--multi"],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        text=True,
+    )
+    selected, _ = fzf.communicate("\n".join(processes))
+
+    if not selected:
+        print("No processes selected.")
+        return
+
+    # Extract PIDs and kill selected processes
+    pids = [line.split()[1] for line in selected.strip().split("\n")]
+    for pid in pids:
+        subprocess.run(
+            f"kill -9 {pid}",
+            shell=True,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+    print(f"Killed processes: {', '.join(pids)}")
+
+
+def add_lora(
+    lora_name_or_path: str,
+    host_port: str,
+    url: str = "http://HOST:PORT/v1/load_lora_adapter",
+    served_model_name: Optional[str] = None,
+    lora_module: Optional[str] = None,  # Added parameter
+) -> dict:
+    url = url.replace("HOST:PORT", host_port)
+    headers = {"Content-Type": "application/json"}
+
+    data = {
+        "lora_name": served_model_name,
+        "lora_path": os.path.abspath(lora_name_or_path),
+    }
+    if lora_module:  # Include lora_module if provided
+        data["lora_module"] = lora_module
+    logger.info(f"{data=}, {headers}, {url=}")
+    # logger.warning(f"Failed to unload LoRA adapter: {str(e)}")
+    try:
+        response = requests.post(url, headers=headers, json=data)
+        response.raise_for_status()
+
+        # Handle potential non-JSON responses
+        try:
+            return response.json()
+        except ValueError:
+            return {
+                "status": "success",
+                "message": (
+                    response.text
+                    if response.text.strip()
+                    else "Request completed with empty response"
+                ),
+            }
+
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Request failed: {str(e)}")
+        return {"error": f"Request failed: {str(e)}"}
+
+
+def unload_lora(lora_name, host_port):
+    try:
+        url = f"http://{host_port}/v1/unload_lora_adapter"
+        logger.info(f"{url=}")
+        headers = {"Content-Type": "application/json"}
+        data = {"lora_name": lora_name}
+        logger.info(f"Unloading LoRA adapter: {data=}")
+        response = requests.post(url, headers=headers, json=data)
+        response.raise_for_status()
+        logger.success(f"Unloaded LoRA adapter: {lora_name}")
+    except requests.exceptions.RequestException as e:
+        return {"error": f"Request failed: {str(e)}"}
+
+
+def serve(
+    model: str,
+    gpu_groups: str,
+    served_model_name: Optional[str] = None,
+    port_start: int = 8155,
+    gpu_memory_utilization: float = 0.93,
+    dtype: str = "bfloat16",
+    max_model_len: int = 8192,
+    enable_lora: bool = False,
+    is_bnb: bool = False,
+    eager: bool = False,
+    chat_template: Optional[str] = None,
+    lora_modules: Optional[List[str]] = None,  # Updated type
+):
+    """Main function to start or kill vLLM containers."""
+
+    """Start vLLM containers with dynamic args."""
+    print("Starting vLLM containers...,")
+    gpu_groups_arr = gpu_groups.split(",")
+    VLLM_BINARY = get_vllm()
+    if enable_lora:
+        VLLM_BINARY = "VLLM_ALLOW_RUNTIME_LORA_UPDATING=True " + VLLM_BINARY
+
+    # Auto-detect quantization based on model name if not explicitly set
+    if not is_bnb and model and ("bnb" in model.lower() or "4bit" in model.lower()):
+        is_bnb = True
+        print(f"Auto-detected quantization for model: {model}")
+
+    # Set environment variables for LoRA if needed
+    if enable_lora:
+        os.environ["VLLM_ALLOW_RUNTIME_LORA_UPDATING"] = "True"
+        print("Enabled runtime LoRA updating")
+
+    for i, gpu_group in enumerate(gpu_groups_arr):
+        port = port_start + i
+        gpu_group = ",".join([str(x) for x in gpu_group])
+        tensor_parallel = len(gpu_group.split(","))
+
+        cmd = [
+            f"CUDA_VISIBLE_DEVICES={gpu_group}",
+            VLLM_BINARY,
+            "serve",
+            model,
+            "--port",
+            str(port),
+            "--tensor-parallel",
+            str(tensor_parallel),
+            "--gpu-memory-utilization",
+            str(gpu_memory_utilization),
+            "--dtype",
+            dtype,
+            "--max-model-len",
+            str(max_model_len),
+            "--enable-prefix-caching",
+            "--disable-log-requests",
+            "--uvicorn-log-level critical",
+        ]
+        if HF_HOME:
+            # insert
+            cmd.insert(0, f"HF_HOME={HF_HOME}")
+        if eager:
+            cmd.append("--enforce-eager")
+
+        if served_model_name:
+            cmd.extend(["--served-model-name", served_model_name])
+
+        if is_bnb:
+            cmd.extend(
+                ["--quantization", "bitsandbytes", "--load-format", "bitsandbytes"]
+            )
+
+        if enable_lora:
+            cmd.extend(["--fully-sharded-loras", "--enable-lora"])
+
+        if chat_template:
+            chat_template = get_chat_template(chat_template)
+            cmd.extend(["--chat-template", chat_template])  # Add chat_template argument
+        if lora_modules:
+            # for lora_module in lora_modules:
+            # len must be even and we will join tuple with `=`
+            assert len(lora_modules) % 2 == 0, "lora_modules must be even"
+            # lora_modulle = [f'{name}={module}' for name, module in zip(lora_module[::2], lora_module[1::2])]
+            # import ipdb;ipdb.set_trace()
+            s = ""
+            for i in range(0, len(lora_modules), 2):
+                name = lora_modules[i]
+                module = lora_modules[i + 1]
+                s += f"{name}={module} "
+
+            cmd.extend(["--lora-modules", s])
+        # add kwargs
+        final_cmd = " ".join(cmd)
+        log_file = f"/tmp/vllm_{port}.txt"
+        final_cmd_with_log = f'"{final_cmd} 2>&1 | tee {log_file}"'
+        run_in_tmux = (
+            f"tmux new-session -d -s vllm_{port} 'bash -c {final_cmd_with_log}'"
+        )
+
+        print(final_cmd)
+        print("Logging to", log_file)
+        os.system(run_in_tmux)
+
+
+def get_vllm():
+    VLLM_BINARY = subprocess.check_output("which vllm", shell=True, text=True).strip()
+    VLLM_BINARY = os.getenv("VLLM_BINARY", VLLM_BINARY)
+    logger.info(f"vLLM binary: {VLLM_BINARY}")
+    assert os.path.exists(
+        VLLM_BINARY
+    ), f"vLLM binary not found at {VLLM_BINARY}, please set VLLM_BINARY env variable"
+    return VLLM_BINARY
+
+
+def get_args():
+    """Parse command line arguments."""
+    example_args = [
+        "svllm serve --model MODEL_NAME --gpus 0,1,2,3",
+        "svllm serve --lora LORA_NAME LORA_PATH --gpus 0,1,2,3",
+        "svllm add_lora --lora LORA_NAME LORA_PATH --host_port localhost:8150",
+        "svllm kill",
+    ]
+
+    parser = argparse.ArgumentParser(
+        description="vLLM Serve Script", epilog="Example: " + " || ".join(example_args)
+    )
+    parser.add_argument(
+        "mode",
+        choices=["serve", "kill", "add_lora", "unload_lora", "list_models"],
+        help="Mode to run the script in",
+    )
+    parser.add_argument("--model", "-m", type=str, help="Model to serve")
+    parser.add_argument(
+        "--gpus",
+        "-g",
+        type=str,
+        help="Comma-separated list of GPU groups",
+        dest="gpu_groups",
+    )
+    parser.add_argument(
+        "--lora",
+        "-l",
+        nargs=2,
+        metavar=("LORA_NAME", "LORA_PATH"),
+        help="Name and path of the LoRA adapter",
+    )
+    parser.add_argument(
+        "--served_model_name", type=str, help="Name of the served model"
+    )
+    parser.add_argument(
+        "--gpu_memory_utilization",
+        "-gmu",
+        type=float,
+        default=0.9,
+        help="GPU memory utilization",
+    )
+    parser.add_argument("--dtype", type=str, default="auto", help="Data type")
+    parser.add_argument(
+        "--max_model_len", "-mml", type=int, default=8192, help="Maximum model length"
+    )
+    parser.add_argument(
+        "--disable_lora",
+        dest="enable_lora",
+        action="store_false",
+        help="Disable LoRA support",
+        default=True,
+    )
+    parser.add_argument("--bnb", action="store_true", help="Enable quantization")
+    parser.add_argument(
+        "--not_verbose", action="store_true", help="Disable verbose logging"
+    )
+    parser.add_argument("--vllm_binary", type=str, help="Path to the vLLM binary")
+    parser.add_argument(
+        "--pipeline_parallel",
+        "-pp",
+        default=1,
+        type=int,
+        help="Number of pipeline parallel stages",
+    )
+    # parser.add_argument(
+    #     "--extra_args",
+    #     nargs=argparse.REMAINDER,
+    #     help="Additional arguments for the serve command",
+    # )
+    parser.add_argument(
+        "--host_port",
+        "-hp",
+        type=str,
+        default="localhost:8150",
+        help="Host and port for the server format: host:port",
+    )
+    parser.add_argument("--eager", action="store_true", help="Enable eager execution")
+    parser.add_argument(
+        "--chat_template",
+        type=str,
+        help="Path to the chat template file",
+    )
+    parser.add_argument(
+        "--lora_modules",
+        "-lm",
+        nargs="+",
+        type=str,
+        help="List of LoRA modules in the format lora_name lora_module",
+    )
+    return parser.parse_args()
+
+
+from speedy_utils import jloads, load_by_ext, memoize
+
+
+def fetch_chat_template(template_name: str = "qwen") -> str:
+    """
+    Fetches a chat template file from a remote repository or local cache.
+
+    Args:
+        template_name (str): Name of the chat template. Defaults to 'qwen'.
+
+    Returns:
+        str: Path to the downloaded or cached chat template file.
+
+    Raises:
+        AssertionError: If the template_name is not supported.
+        ValueError: If the file URL is invalid.
+    """
+    supported_templates = [
+        "alpaca",
+        "chatml",
+        "gemma-it",
+        "llama-2-chat",
+        "mistral-instruct",
+        "qwen2.5-instruct",
+        "saiga",
+        "vicuna",
+        "qwen",
+    ]
+    assert template_name in supported_templates, (
+        f"Chat template '{template_name}' not supported. "
+        f"Please choose from {supported_templates}."
+    )
+
+    # Map 'qwen' to 'qwen2.5-instruct'
+    if template_name == "qwen":
+        template_name = "qwen2.5-instruct"
+
+    remote_url = (
+        f"https://raw.githubusercontent.com/chujiezheng/chat_templates/"
+        f"main/chat_templates/{template_name}.jinja"
+    )
+    local_cache_path = f"/tmp/chat_template_{template_name}.jinja"
+
+    if remote_url.startswith("http"):
+        import requests
+
+        response = requests.get(remote_url)
+        with open(local_cache_path, "w") as file:
+            file.write(response.text)
+        return local_cache_path
+
+    raise ValueError("The file URL must be a valid HTTP URL.")
+
+
+def get_chat_template(template_name: str) -> str:
+    return fetch_chat_template(template_name)
+
+
+def main():
+    """Main entry point for the script."""
+
+    args = get_args()
+
+    if args.mode == "serve":
+        # Handle LoRA model serving via the new --lora argument
+        if args.lora:
+            lora_name, lora_path = args.lora
+            if not args.lora_modules:
+                args.lora_modules = [lora_name, lora_path]
+            # Try to get the model from LoRA config if not specified
+            if args.model is None:
+                lora_config = os.path.join(lora_path, "adapter_config.json")
+                if os.path.exists(lora_config):
+                    config = load_by_ext(lora_config)
+                    model_name = config.get("base_model_name_or_path")
+                    # Handle different quantization suffixes
+                    if model_name.endswith("-unsloth-bnb-4bit") and not args.bnb:
+                        model_name = model_name.replace("-unsloth-bnb-4bit", "")
+                    elif model_name.endswith("-bnb-4bit") and not args.bnb:
+                        model_name = model_name.replace("-bnb-4bit", "")
+                    logger.info(f"Model name from LoRA config: {model_name}")
+                    args.model = model_name
+
+        # Fall back to existing logic for other cases (already specified lora_modules)
+        if args.model is None and args.lora_modules is not None and not args.lora:
+            lora_config = os.path.join(args.lora_modules[1], "adapter_config.json")
+            if os.path.exists(lora_config):
+                config = load_by_ext(lora_config)
+                model_name = config.get("base_model_name_or_path")
+                if model_name.endswith("-unsloth-bnb-4bit") and not args.bnb:
+                    model_name = model_name.replace("-unsloth-bnb-4bit", "")
+                elif model_name.endswith("-bnb-4bit") and not args.bnb:
+                    model_name = model_name.replace("-bnb-4bit", "")
+                logger.info(f"Model name from LoRA config: {model_name}")
+                args.model = model_name
+        # port_start from hostport
+        port_start = int(args.host_port.split(":")[-1])
+        serve(
+            args.model,
+            args.gpu_groups,
+            args.served_model_name,
+            port_start,
+            args.gpu_memory_utilization,
+            args.dtype,
+            args.max_model_len,
+            args.enable_lora,
+            args.bnb,
+            args.eager,
+            args.chat_template,
+            args.lora_modules,
+        )
+
+    elif args.mode == "kill":
+        kill_existing_vllm(args.vllm_binary)
+    elif args.mode == "add_lora":
+        if args.lora:
+            lora_name, lora_path = args.lora
+            add_lora(lora_path, host_port=args.host_port, served_model_name=lora_name)
+        else:
+            # Fallback to old behavior
+            lora_name = args.model
+            add_lora(
+                lora_name,
+                host_port=args.host_port,
+                served_model_name=args.served_model_name,
+            )
+    elif args.mode == "unload_lora":
+        if args.lora:
+            lora_name = args.lora[0]
+        else:
+            lora_name = args.model
+        unload_lora(lora_name, host_port=args.host_port)
+    elif args.mode == "list_models":
+        model_list(args.host_port)
+    else:
+        raise ValueError(f"Unknown mode: {args.mode}, ")
+
+
+if __name__ == "__main__":
+    main()

speedy_utils/__init__.py

@@ -41,7 +41,7 @@ from .common.utils_print import (
 
 # Multi-worker processing
 from .multi_worker.process import multi_process
-from .multi_worker.thread import multi_threaad_standard, multi_thread
+from .multi_worker.thread import multi_thread
 
 # Define __all__ explicitly
 __all__ = [
@@ -79,7 +79,6 @@ __all__ = [
     # Multi-worker processing
     "multi_process",
     "multi_thread",
-    "multi_threaad_standard",
 ]
 
 # Setup default logger

speedy_utils/all.py

@@ -64,7 +64,6 @@ from speedy_utils import (  # Clock module; Function decorators; Cache utilities
     memoize,
     mkdir_or_exist,
     multi_process,
-    multi_threaad_standard,
     multi_thread,
     print_table,
     retry_runtime,
@@ -157,5 +156,4 @@ __all__ = [
     # Multi-worker processing
     "multi_process",
     "multi_thread",
-    "multi_threaad_standard",
 ]

speedy_utils/common/clock.py

@@ -96,6 +96,11 @@ class Clock:
             )
             return
         current_time = time.time()
+        if self.last_checkpoint is None:
+            logger.opt(depth=2).warning(
+                "Last checkpoint is not set. Please call start() before using this method."
+            )
+            return
         elapsed = current_time - self.last_checkpoint
         self.last_checkpoint = current_time
         return elapsed
@@ -111,6 +116,11 @@ class Clock:
                 "Timer has not been started. Please call start() before using this method."
             )
             return
+        if self.last_checkpoint is None:
+            logger.opt(depth=2).warning(
+                "Last checkpoint is not set. Please call start() before using this method."
+            )
+            return
         return time.time() - self.last_checkpoint
 
     def update_task(self, task_name):

speedy_utils/common/utils_misc.py

@@ -6,7 +6,6 @@ import sys
 from collections.abc import Callable
 from typing import Any, List
 
-from IPython import get_ipython
 from pydantic import BaseModel
 
 

speedy_utils/multi_worker/thread.py

@@ -1,13 +1,12 @@
 """Provides thread-based parallel execution utilities."""
 
-import inspect
 import os
 import time
 import traceback
 from collections.abc import Callable, Iterable
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from itertools import islice
-from typing import Any, TypeVar, cast
+from typing import Any, TypeVar
 
 from loguru import logger
 
@@ -80,7 +79,7 @@ def multi_thread(
                       ``False`` the failing task’s result becomes ``None``.
     **fixed_kwargs  – static keyword args forwarded to every ``func()`` call.
     """
-    from speedy_utils import dump_json_or_pickle, identify, load_by_ext
+    from speedy_utils import dump_json_or_pickle, load_by_ext
 
     if n_proc > 1:
         import tempfile
@@ -297,10 +296,27 @@ def multi_thread(
     return results
 
 
-def multi_threaad_standard(fn, items, workers=4):
-    """
+def multi_thread_standard(
+    fn: Callable[[Any], Any], items: Iterable[Any], workers: int = 4
+) -> list[Any]:
+    """Execute a function using standard ThreadPoolExecutor.
+
     A standard implementation of multi-threading using ThreadPoolExecutor.
     Ensures the order of results matches the input order.
+
+    Parameters
+    ----------
+    fn : Callable
+        The function to execute for each item.
+    items : Iterable
+        The items to process.
+    workers : int, optional
+        Number of worker threads, by default 4.
+
+    Returns
+    -------
+    list
+        Results in same order as input items.
     """
     with ThreadPoolExecutor(max_workers=workers) as executor:
         futures = [executor.submit(fn, item) for item in items]
@@ -308,4 +324,4 @@ def multi_threaad_standard(fn, items, workers=4):
     return results
 
 
-__all__ = ["multi_thread", "multi_threaad_standard"]
+__all__ = ["multi_thread", "multi_thread_standard"]

{speedy_utils-0.1.28.dist-info → speedy_utils-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: speedy-utils
-Version: 0.1.28
+Version: 1.0.0
 Summary: Fast and easy-to-use package for data science
 Author: AnhVTH
 Author-email: anhvth.226@gmail.com
@@ -19,11 +19,12 @@ Requires-Dist: fastprogress
 Requires-Dist: freezegun (>=1.5.1,<2.0.0)
 Requires-Dist: ipdb
 Requires-Dist: ipywidgets
-Requires-Dist: json-repair
+Requires-Dist: json-repair (>=0.40.0,<0.41.0)
 Requires-Dist: jupyterlab
 Requires-Dist: loguru
 Requires-Dist: matplotlib
 Requires-Dist: numpy
+Requires-Dist: packaging (>=23.2,<25)
 Requires-Dist: pandas
 Requires-Dist: pydantic
 Requires-Dist: requests
@@ -261,29 +262,6 @@ Ensure all dependencies are installed before running tests:
 pip install -r requirements.txt
 ```
 
-## Data Arguments
-
-Define and parse data arguments using a dataclass:
-
-```python
-from dataclasses import dataclass
-from speedy_utils.common.dataclass_parser import ArgsParser
-
-@dataclass
-class ExampleArgs(ArgsParser):
-    from_peft: str = "./outputs/llm_hn_qw32b/hn_results_r3/"
-    model_name_or_path: str = "Qwen/Qwen2.5-32B-Instruct-AWQ"
-    use_fp16: bool = False
-    batch_size: int = 1
-    max_length: int = 512
-    cache_dir: str = ".cache/run_embeds"
-    output_dir: str = ".cache"
-    input_file: str = ".cache/doc.csv"
-    output_name: str = "qw32b_r3"
-
-args = ExampleArgs.parse_args()
-print(args)
-```
 
 Run the script to parse and display the arguments:
 
@@ -299,5 +277,3 @@ Example output:
 
 Please ensure your code adheres to the project's coding standards and includes appropriate tests.
 
-
-

speedy_utils-1.0.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+llm_utils/__init__.py,sha256=4IO_cP7FlFvV57W7_AkJGdXWcZfWALkr6UwR9s9QEF4,701
+llm_utils/chat_format.py,sha256=ZY2HYv3FPL2xiMxbbO-huIwT5LZrcJm_if_us-2eSZ4,15094
+llm_utils/group_messages.py,sha256=GKMQkenQf-6DD_1EJa11UBj7-VfkGT7xVhR_B_zMzqY,3868
+llm_utils/lm.py,sha256=3d3b9UMtIeKcG6vpXHwuDZ3QP46X1aSGeMvayy3tmHs,29044
+llm_utils/lm_classification.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+llm_utils/load_chat_dataset.py,sha256=hsPPlOmZEDqsg7GQD7SgxTEGJky6JDm6jnG3JHbpjb4,1895
+llm_utils/scripts/vllm_load_balancer.py,sha256=uSjGd_jOmI9W9eVOhiOXbeUnZkQq9xG4bCVzhmpupcA,16096
+llm_utils/scripts/vllm_serve.py,sha256=-gXF3DVs7sfZ4mVmv_0OFheqytMQbr73YkS3bQlFdpE,15818
+speedy_utils/__init__.py,sha256=I2bSfDIE9yRF77tnHW0vqfExDA2m1gUx4AH8C9XmGtg,1707
+speedy_utils/all.py,sha256=A9jiKGjo950eg1pscS9x38OWAjKGyusoAN5mrfweY4E,3090
+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=r_r42qCWuNcu0_aH7musf2BWvcJfgZrD81G28mDcolw,2226
+speedy_utils/common/logger.py,sha256=NIOlhhACpcc0BUTSJ8oDYrLp23J2gW_KJFyRVdLN2tY,6432
+speedy_utils/common/report_manager.py,sha256=dgGfS_fHbZiQMsLzkgnj0OfB758t1x6B4MhjsetSl9A,3930
+speedy_utils/common/utils_cache.py,sha256=gXX5qTXpCG3qDgjnOsSvxM4LkQurmcsg4QRv_zOBG1E,8378
+speedy_utils/common/utils_io.py,sha256=vXhgrMSse_5yuP7yiSjdqKgOu8pz983glelquyNjbkE,4809
+speedy_utils/common/utils_misc.py,sha256=nsQOu2jcplcFHVQ1CnOjEpNcdxIINveGxB493Cqo63U,1812
+speedy_utils/common/utils_print.py,sha256=QRaL2QPbks4Mtol_gJy3ZdahgUfzUEtcOp4--lBlzYI,6709
+speedy_utils/multi_worker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+speedy_utils/multi_worker/process.py,sha256=XwQlffxzRFnCVeKjDNBZDwFfUQHiJiuFA12MRGJVru8,6708
+speedy_utils/multi_worker/thread.py,sha256=9pXjvgjD0s0Hp0cZ6I3M0ndp1OlYZ1yvqbs_bcun_Kw,12775
+speedy_utils/scripts/mpython.py,sha256=ZzkBWI5Xw3vPoMx8xQt2x4mOFRjtwWqfvAJ5_ngyWgw,3816
+speedy_utils-1.0.0.dist-info/METADATA,sha256=nIcZcNBPA9_eUs7on52UMVtcV43lmVFRJLHLptk5AA0,7165
+speedy_utils-1.0.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+speedy_utils-1.0.0.dist-info/entry_points.txt,sha256=fsv8_lMg62BeswoUHrqfj2u6q2l4YcDCw7AgQFg6GRw,61
+speedy_utils-1.0.0.dist-info/RECORD,,