speedy-utils 1.1.19__py3-none-any.whl → 1.1.20__py3-none-any.whl

llm_utils/lm/openai_memoize.py

@@ -1,4 +1,5 @@
 from openai import OpenAI, AsyncOpenAI
+from typing import Any, Callable
 
 from speedy_utils.common.utils_cache import memoize
 
@@ -30,6 +31,8 @@ class MOpenAI(OpenAI):
     - If you need a shared cache across instances, or more advanced cache controls,
         modify `memoize` or wrap at a class/static level instead of assigning to the
         bound method.
+    - Type information is now fully preserved by the memoize decorator, eliminating
+        the need for type casting.
 
     Example
             m = MOpenAI(api_key="...", model="gpt-4")
@@ -40,7 +43,12 @@ class MOpenAI(OpenAI):
     def __init__(self, *args, cache=True, **kwargs):
         super().__init__(*args, **kwargs)
         if cache:
-            self.post = memoize(self.post) # type: ignore
+            # Create a memoized wrapper for the instance's post method.
+            # The memoize decorator now preserves exact type information,
+            # so no casting is needed.
+            orig_post = self.post
+            memoized = memoize(orig_post)
+            self.post = memoized
 
 
 class MAsyncOpenAI(AsyncOpenAI):

llm_utils/vector_cache/core.py

@@ -13,50 +13,51 @@ import numpy as np
 class VectorCache:
     """
     A caching layer for text embeddings with support for multiple backends.
-    
+
     This cache is designed to be safe for multi-process environments where multiple
     processes may access the same cache file simultaneously. It uses SQLite WAL mode
     and retry logic with exponential backoff to handle concurrent access.
-    
+
     Examples:
         # OpenAI API
         from llm_utils import VectorCache
         cache = VectorCache("https://api.openai.com/v1", api_key="your-key")
         embeddings = cache.embeds(["Hello world", "How are you?"])
-        
+
         # Custom OpenAI-compatible server (auto-detects model)
         cache = VectorCache("http://localhost:8000/v1", api_key="abc")
-        
+
         # Transformers (Sentence Transformers)
         cache = VectorCache("sentence-transformers/all-MiniLM-L6-v2")
-        
+
         # vLLM (local model)
         cache = VectorCache("/path/to/model")
-        
+
         # Explicit backend specification
         cache = VectorCache("model-name", backend="transformers")
-        
+
         # Eager loading (default: False) - load model immediately for better performance
         cache = VectorCache("model-name", lazy=False)
-        
+
         # Lazy loading - load model only when needed (may cause performance issues)
         cache = VectorCache("model-name", lazy=True)
-        
+
     Multi-Process Safety:
         The cache uses SQLite WAL (Write-Ahead Logging) mode and implements retry logic
         with exponential backoff to handle database locks. Multiple processes can safely
         read and write to the same cache file simultaneously.
-        
+
         Race Condition Protection:
         - Uses INSERT OR IGNORE to prevent overwrites when multiple processes compute the same text
         - The first process to successfully cache a text wins, subsequent attempts are ignored
         - This ensures deterministic results even with non-deterministic embedding models
-        
+
         For best performance in multi-process scenarios, consider:
         - Using separate cache files per process if cache hits are low
         - Coordinating cache warm-up to avoid redundant computation
         - Monitor for excessive lock contention in high-concurrency scenarios
     """
+
     def __init__(
         self,
         url_or_model: str,
@@ -80,7 +81,7 @@ class VectorCache:
         # SQLite parameters
         sqlite_chunk_size: int = 999,
         sqlite_cache_size: int = 10000,
-        sqlite_mmap_size: int = 268435456,
+        sqlite_mmap_size: int = 268435456,  # 256MB
         # Processing parameters
         embedding_batch_size: int = 20_000,
         # Other parameters
@@ -91,11 +92,11 @@ class VectorCache:
         self.embed_size = embed_size
         self.verbose = verbose
         self.lazy = lazy
-        
+
         self.backend = self._determine_backend(backend)
         if self.verbose and backend is None:
             print(f"Auto-detected backend: {self.backend}")
-        
+
         # Store all configuration parameters
         self.config = {
             # OpenAI
@@ -119,18 +120,20 @@ class VectorCache:
             # Processing
             "embedding_batch_size": embedding_batch_size,
         }
-        
+
         # Auto-detect model_name for OpenAI if using custom URL and default model
-        if (self.backend == "openai" and 
-            model_name == "text-embedding-3-small" and 
-            self.url_or_model != "https://api.openai.com/v1"):
+        if (
+            self.backend == "openai"
+            and model_name == "text-embedding-3-small"
+            and self.url_or_model != "https://api.openai.com/v1"
+        ):
             if self.verbose:
                 print(f"Attempting to auto-detect model from {self.url_or_model}...")
             try:
                 import openai
+
                 client = openai.OpenAI(
-                    base_url=self.url_or_model, 
-                    api_key=self.config["api_key"]
+                    base_url=self.url_or_model, api_key=self.config["api_key"]
                 )
                 models = client.models.list()
                 if models.data:
@@ -147,7 +150,7 @@ class VectorCache:
                     print(f"Model auto-detection failed: {e}, using default model")
                 # Fallback to default if auto-detection fails
                 pass
-        
+
         # Set default db_path if not provided
         if db_path is None:
             if self.backend == "openai":
@@ -155,19 +158,21 @@ class VectorCache:
             else:
                 model_id = self.url_or_model
             safe_name = hashlib.sha1(model_id.encode("utf-8")).hexdigest()[:16]
-            self.db_path = Path.home() / ".cache" / "embed" / f"{self.backend}_{safe_name}.sqlite"
+            self.db_path = (
+                Path.home() / ".cache" / "embed" / f"{self.backend}_{safe_name}.sqlite"
+            )
         else:
             self.db_path = Path(db_path)
-        
+
         # Ensure the directory exists
         self.db_path.parent.mkdir(parents=True, exist_ok=True)
-        
+
         self.conn = sqlite3.connect(self.db_path)
         self._optimize_connection()
         self._ensure_schema()
         self._model = None  # Lazy loading
         self._client = None  # For OpenAI client
-        
+
         # Load model/client if not lazy
         if not self.lazy:
             if self.verbose:
@@ -179,34 +184,41 @@ class VectorCache:
             if self.verbose:
                 print(f"✓ {self.backend.upper()} model/client loaded successfully")
 
-    def _determine_backend(self, backend: Optional[Literal["vllm", "transformers", "openai"]]) -> str:
+    def _determine_backend(
+        self, backend: Optional[Literal["vllm", "transformers", "openai"]]
+    ) -> str:
         """Determine the appropriate backend based on url_or_model and user preference."""
         if backend is not None:
             valid_backends = ["vllm", "transformers", "openai"]
             if backend not in valid_backends:
-                raise ValueError(f"Invalid backend '{backend}'. Must be one of: {valid_backends}")
+                raise ValueError(
+                    f"Invalid backend '{backend}'. Must be one of: {valid_backends}"
+                )
             return backend
-            
+
         if self.url_or_model.startswith("http"):
             return "openai"
-        
+
         # Default to vllm for local models
         return "vllm"
+
     def _try_infer_model_name(self, model_name: Optional[str]) -> Optional[str]:
         """Infer model name for OpenAI backend if not explicitly provided."""
         if model_name:
             return model_name
-        if 'https://' in self.url_or_model:
-            model_name =  "text-embedding-3-small"
-        
-        if 'http://localhost' in self.url_or_model:
+        if "https://" in self.url_or_model:
+            model_name = "text-embedding-3-small"
+
+        if "http://localhost" in self.url_or_model:
             from openai import OpenAI
-            client = OpenAI(base_url=self.url_or_model, api_key='abc')
-            model_name =  client.models.list().data[0].id
+
+            client = OpenAI(base_url=self.url_or_model, api_key="abc")
+            model_name = client.models.list().data[0].id
 
         # Default model name
-        print('Infer model name:', model_name)
+        print("Infer model name:", model_name)
         return model_name
+
     def _optimize_connection(self) -> None:
         """Optimize SQLite connection for bulk operations and multi-process safety."""
         # Performance optimizations for bulk operations
@@ -214,13 +226,21 @@ class VectorCache:
             "PRAGMA journal_mode=WAL"
         )  # Write-Ahead Logging for better concurrency
         self.conn.execute("PRAGMA synchronous=NORMAL")  # Faster writes, still safe
-        self.conn.execute(f"PRAGMA cache_size={self.config['sqlite_cache_size']}")  # Configurable cache
+        self.conn.execute(
+            f"PRAGMA cache_size={self.config['sqlite_cache_size']}"
+        )  # Configurable cache
         self.conn.execute("PRAGMA temp_store=MEMORY")  # Use memory for temp storage
-        self.conn.execute(f"PRAGMA mmap_size={self.config['sqlite_mmap_size']}")  # Configurable memory mapping
-        
+        self.conn.execute(
+            f"PRAGMA mmap_size={self.config['sqlite_mmap_size']}"
+        )  # Configurable memory mapping
+
         # Multi-process safety improvements
-        self.conn.execute("PRAGMA busy_timeout=30000")  # Wait up to 30 seconds for locks
-        self.conn.execute("PRAGMA wal_autocheckpoint=1000")  # Checkpoint WAL every 1000 pages
+        self.conn.execute(
+            "PRAGMA busy_timeout=30000"
+        )  # Wait up to 30 seconds for locks
+        self.conn.execute(
+            "PRAGMA wal_autocheckpoint=1000"
+        )  # Checkpoint WAL every 1000 pages
 
     def _ensure_schema(self) -> None:
         self.conn.execute("""
@@ -239,22 +259,24 @@ class VectorCache:
     def _load_openai_client(self) -> None:
         """Load OpenAI client."""
         import openai
+
         self._client = openai.OpenAI(
-            base_url=self.url_or_model, 
-            api_key=self.config["api_key"]
+            base_url=self.url_or_model, api_key=self.config["api_key"]
         )
 
     def _load_model(self) -> None:
         """Load the model for vLLM or Transformers."""
         if self.backend == "vllm":
             from vllm import LLM  # type: ignore[import-not-found]
-            
-            gpu_memory_utilization = cast(float, self.config["vllm_gpu_memory_utilization"])
+
+            gpu_memory_utilization = cast(
+                float, self.config["vllm_gpu_memory_utilization"]
+            )
             tensor_parallel_size = cast(int, self.config["vllm_tensor_parallel_size"])
             dtype = cast(str, self.config["vllm_dtype"])
             trust_remote_code = cast(bool, self.config["vllm_trust_remote_code"])
             max_model_len = cast(Optional[int], self.config["vllm_max_model_len"])
-            
+
             vllm_kwargs = {
                 "model": self.url_or_model,
                 "task": "embed",
@@ -263,18 +285,23 @@ class VectorCache:
                 "dtype": dtype,
                 "trust_remote_code": trust_remote_code,
             }
-            
+
             if max_model_len is not None:
                 vllm_kwargs["max_model_len"] = max_model_len
-            
+
             try:
                 self._model = LLM(**vllm_kwargs)
             except (ValueError, AssertionError, RuntimeError) as e:
                 error_msg = str(e).lower()
-                if ("kv cache" in error_msg and "gpu_memory_utilization" in error_msg) or \
-                   ("memory" in error_msg and ("gpu" in error_msg or "insufficient" in error_msg)) or \
-                   ("free memory" in error_msg and "initial" in error_msg) or \
-                   ("engine core initialization failed" in error_msg):
+                if (
+                    ("kv cache" in error_msg and "gpu_memory_utilization" in error_msg)
+                    or (
+                        "memory" in error_msg
+                        and ("gpu" in error_msg or "insufficient" in error_msg)
+                    )
+                    or ("free memory" in error_msg and "initial" in error_msg)
+                    or ("engine core initialization failed" in error_msg)
+                ):
                     raise ValueError(
                         f"Insufficient GPU memory for vLLM model initialization. "
                         f"Current vllm_gpu_memory_utilization ({gpu_memory_utilization}) may be too low. "
@@ -288,27 +315,39 @@ class VectorCache:
                 else:
                     raise
         elif self.backend == "transformers":
-            from transformers import AutoTokenizer, AutoModel  # type: ignore[import-not-found]
-            import torch  # type: ignore[import-not-found]
-            
+            import torch  # type: ignore[import-not-found] # noqa: F401
+            from transformers import (  # type: ignore[import-not-found]
+                AutoModel,
+                AutoTokenizer,
+            )
+
             device = self.config["transformers_device"]
             # Handle "auto" device selection - default to CPU for transformers to avoid memory conflicts
             if device == "auto":
                 device = "cpu"  # Default to CPU to avoid GPU memory conflicts with vLLM
-            
-            tokenizer = AutoTokenizer.from_pretrained(self.url_or_model, padding_side='left', trust_remote_code=self.config["transformers_trust_remote_code"])
-            model = AutoModel.from_pretrained(self.url_or_model, trust_remote_code=self.config["transformers_trust_remote_code"])
-            
+
+            tokenizer = AutoTokenizer.from_pretrained(
+                self.url_or_model,
+                padding_side="left",
+                trust_remote_code=self.config["transformers_trust_remote_code"],
+            )
+            model = AutoModel.from_pretrained(
+                self.url_or_model,
+                trust_remote_code=self.config["transformers_trust_remote_code"],
+            )
+
             # Move model to device
             model.to(device)
             model.eval()
-            
+
             self._model = {"tokenizer": tokenizer, "model": model, "device": device}
 
     def _get_embeddings(self, texts: list[str]) -> list[list[float]]:
         """Get embeddings using the configured backend."""
         assert isinstance(texts, list), "texts must be a list"
-        assert all(isinstance(t, str) for t in texts), "all elements in texts must be strings"
+        assert all(isinstance(t, str) for t in texts), (
+            "all elements in texts must be strings"
+        )
         if self.backend == "openai":
             return self._get_openai_embeddings(texts)
         elif self.backend == "vllm":
@@ -321,10 +360,14 @@ class VectorCache:
     def _get_openai_embeddings(self, texts: list[str]) -> list[list[float]]:
         """Get embeddings using OpenAI API."""
         assert isinstance(texts, list), "texts must be a list"
-        assert all(isinstance(t, str) for t in texts), "all elements in texts must be strings"
+        assert all(isinstance(t, str) for t in texts), (
+            "all elements in texts must be strings"
+        )
         # Assert valid model_name for OpenAI backend
         model_name = self.config["model_name"]
-        assert model_name is not None and model_name.strip(), f"Invalid model_name for OpenAI backend: {model_name}. Model name must be provided and non-empty."
+        assert model_name is not None and model_name.strip(), (
+            f"Invalid model_name for OpenAI backend: {model_name}. Model name must be provided and non-empty."
+        )
 
         if self._client is None:
             if self.verbose:
@@ -332,10 +375,9 @@ class VectorCache:
             self._load_openai_client()
             if self.verbose:
                 print("✓ OpenAI client loaded successfully")
-        
+
         response = self._client.embeddings.create(  # type: ignore
-            model=model_name, 
-            input=texts
+            model=model_name, input=texts
         )
         embeddings = [item.embedding for item in response.data]
         return embeddings
@@ -343,14 +385,16 @@ class VectorCache:
     def _get_vllm_embeddings(self, texts: list[str]) -> list[list[float]]:
         """Get embeddings using vLLM."""
         assert isinstance(texts, list), "texts must be a list"
-        assert all(isinstance(t, str) for t in texts), "all elements in texts must be strings"
+        assert all(isinstance(t, str) for t in texts), (
+            "all elements in texts must be strings"
+        )
         if self._model is None:
             if self.verbose:
                 print("🔧 Loading vLLM model...")
             self._load_model()
             if self.verbose:
                 print("✓ vLLM model loaded successfully")
-        
+
         outputs = self._model.embed(texts)  # type: ignore
         embeddings = [o.outputs.embedding for o in outputs]
         return embeddings
@@ -358,26 +402,30 @@ class VectorCache:
     def _get_transformers_embeddings(self, texts: list[str]) -> list[list[float]]:
         """Get embeddings using transformers directly."""
         assert isinstance(texts, list), "texts must be a list"
-        assert all(isinstance(t, str) for t in texts), "all elements in texts must be strings"
+        assert all(isinstance(t, str) for t in texts), (
+            "all elements in texts must be strings"
+        )
         if self._model is None:
             if self.verbose:
                 print("🔧 Loading Transformers model...")
             self._load_model()
             if self.verbose:
                 print("✓ Transformers model loaded successfully")
-        
+
         if not isinstance(self._model, dict):
             raise ValueError("Model not loaded properly for transformers backend")
-        
+
         tokenizer = self._model["tokenizer"]
         model = self._model["model"]
         device = self._model["device"]
-        
-        normalize_embeddings = cast(bool, self.config["transformers_normalize_embeddings"])
-        
+
+        normalize_embeddings = cast(
+            bool, self.config["transformers_normalize_embeddings"]
+        )
+
         # For now, use a default max_length
         max_length = 8192
-        
+
         # Tokenize
         batch_dict = tokenizer(
             texts,
@@ -386,35 +434,43 @@ class VectorCache:
             max_length=max_length,
             return_tensors="pt",
         )
-        
+
         # Move to device
         batch_dict = {k: v.to(device) for k, v in batch_dict.items()}
-        
+
         # Run model
         import torch  # type: ignore[import-not-found]
+
         with torch.no_grad():
             outputs = model(**batch_dict)
-        
+
         # Apply last token pooling
-        embeddings = self._last_token_pool(outputs.last_hidden_state, batch_dict['attention_mask'])
-        
+        embeddings = self._last_token_pool(
+            outputs.last_hidden_state, batch_dict["attention_mask"]
+        )
+
         # Normalize if needed
         if normalize_embeddings:
             import torch.nn.functional as F  # type: ignore[import-not-found]
+
             embeddings = F.normalize(embeddings, p=2, dim=1)
-        
+
         return embeddings.cpu().numpy().tolist()
 
     def _last_token_pool(self, last_hidden_states, attention_mask):
         """Apply last token pooling to get embeddings."""
         import torch  # type: ignore[import-not-found]
-        left_padding = (attention_mask[:, -1].sum() == attention_mask.shape[0])
+
+        left_padding = attention_mask[:, -1].sum() == attention_mask.shape[0]
         if left_padding:
             return last_hidden_states[:, -1]
         else:
             sequence_lengths = attention_mask.sum(dim=1) - 1
             batch_size = last_hidden_states.shape[0]
-            return last_hidden_states[torch.arange(batch_size, device=last_hidden_states.device), sequence_lengths]
+            return last_hidden_states[
+                torch.arange(batch_size, device=last_hidden_states.device),
+                sequence_lengths,
+            ]
 
     def _hash_text(self, text: str) -> str:
         return hashlib.sha1(text.encode("utf-8")).hexdigest()
@@ -423,33 +479,36 @@ class VectorCache:
         """Execute SQLite query with retry logic for multi-process safety."""
         max_retries = 3
         base_delay = 0.05  # 50ms base delay for reads (faster than writes)
-        
+
         last_exception = None
-        
+
         for attempt in range(max_retries + 1):
             try:
                 if params is None:
                     return self.conn.execute(query)
                 else:
                     return self.conn.execute(query, params)
-                    
+
             except sqlite3.OperationalError as e:
                 last_exception = e
                 if "database is locked" in str(e).lower() and attempt < max_retries:
                     # Exponential backoff: 0.05s, 0.1s, 0.2s
-                    delay = base_delay * (2 ** attempt)
+                    delay = base_delay * (2**attempt)
                     if self.verbose:
-                        print(f"⚠️  Database locked on read, retrying in {delay:.2f}s (attempt {attempt + 1}/{max_retries + 1})")
+                        print(
+                            f"⚠️  Database locked on read, retrying in {delay:.2f}s (attempt {attempt + 1}/{max_retries + 1})"
+                        )
                     import time
+
                     time.sleep(delay)
                     continue
                 else:
                     # Re-raise if not a lock error or max retries exceeded
                     raise
-            except Exception as e:
+            except Exception:
                 # Re-raise any other exceptions
                 raise
-        
+
         # This should never be reached, but satisfy the type checker
         raise last_exception or RuntimeError("Failed to execute query after retries")
 
@@ -465,7 +524,9 @@ class VectorCache:
         computing missing embeddings.
         """
         assert isinstance(texts, list), "texts must be a list"
-        assert all(isinstance(t, str) for t in texts), "all elements in texts must be strings"
+        assert all(isinstance(t, str) for t in texts), (
+            "all elements in texts must be strings"
+        )
         if not texts:
             return np.empty((0, 0), dtype=np.float32)
         t = time()
@@ -502,7 +563,9 @@ class VectorCache:
 
         if missing_items:
             if self.verbose:
-                print(f"Computing {len(missing_items)}/{len(texts)} missing embeddings...")
+                print(
+                    f"Computing {len(missing_items)}/{len(texts)} missing embeddings..."
+                )
             self._process_missing_items_with_batches(missing_items, hit_map)
 
         # Return embeddings in the original order
@@ -511,92 +574,81 @@ class VectorCache:
             print(f"Retrieved {len(texts)} embeddings in {elapsed:.2f} seconds")
         return np.vstack([hit_map[h] for h in hashes])
 
-    def _process_missing_items_with_batches(self, missing_items: list[tuple[str, str]], hit_map: dict[str, np.ndarray]) -> None:
+    def _process_missing_items_with_batches(
+        self, missing_items: list[tuple[str, str]], hit_map: dict[str, np.ndarray]
+    ) -> None:
         """
-        Process missing items in batches with progress bar and incremental DB insertion.
+        Process missing items in batches with simple progress tracking.
         """
         t = time()  # Track total processing time
-        
-        # Try to import tqdm, fall back to simple progress if not available
-        tqdm = None  # avoid "possibly unbound" in type checker
-        use_tqdm = False
-        try:
-            from tqdm import tqdm as _tqdm  # type: ignore[import-not-found]
-            tqdm = _tqdm
-            use_tqdm = True
-        except ImportError:
-            use_tqdm = False
-            if self.verbose:
-                print("tqdm not available, using simple progress reporting")
-        
+
         batch_size = self.config["embedding_batch_size"]
         total_items = len(missing_items)
-        
+
         if self.verbose:
-            print(f"Computing embeddings for {total_items} missing texts in batches of {batch_size}...")
+            print(
+                f"Computing embeddings for {total_items} missing texts in batches of {batch_size}..."
+            )
             if self.backend in ["vllm", "transformers"] and self._model is None:
                 print("⚠️  Model will be loaded on first batch (lazy loading enabled)")
             elif self.backend in ["vllm", "transformers"]:
                 print("✓ Model already loaded, ready for efficient batch processing")
-        
-        # Create progress bar
-        pbar = None
-        processed_count = 0
-        if use_tqdm and tqdm is not None:
-            pbar = tqdm(total=total_items, desc="Computing embeddings", unit="texts")
-        
+
         # Track total committed items
         total_committed = 0
-        
-        try:
-            # Process in batches
-            for i in range(0, total_items, batch_size):
-                batch_items = missing_items[i:i + batch_size]
-                batch_texts = [text for text, _ in batch_items]
-                
-                # Get embeddings for this batch
-                batch_embeds = self._get_embeddings(batch_texts)
-                
-                # Prepare batch data for immediate insert
-                batch_data: list[tuple[str, str, bytes]] = []
-                for (text, h), vec in zip(batch_items, batch_embeds):
-                    arr = np.asarray(vec, dtype=np.float32)
-                    batch_data.append((h, text, arr.tobytes()))
-                    hit_map[h] = arr
-                
-                # Immediate commit after each batch
-                self._bulk_insert(batch_data)
-                total_committed += len(batch_data)
-                
-                # Update progress
-                batch_size_actual = len(batch_items)
-                if use_tqdm:
-                    pbar.update(batch_size_actual) # type: ignore
-                else:
-                    processed_count += batch_size_actual
-                    if self.verbose:
-                        print(f"Progress: {processed_count}/{total_items} embeddings computed, {total_committed} committed")
-        
-        finally:
-            # Clean up progress bar
-            if pbar is not None:
-                pbar.close()
-                
+        processed_count = 0
+
+        # Process in batches
+        for i in range(0, total_items, batch_size):
+            batch_items = missing_items[i : i + batch_size]
+            batch_texts = [text for text, _ in batch_items]
+
+            # Get embeddings for this batch
+            batch_embeds = self._get_embeddings(batch_texts)
+
+            # Prepare batch data for immediate insert
+            batch_data: list[tuple[str, str, bytes]] = []
+            for (text, h), vec in zip(batch_items, batch_embeds):
+                arr = np.asarray(vec, dtype=np.float32)
+                batch_data.append((h, text, arr.tobytes()))
+                hit_map[h] = arr
+
+            # Immediate commit after each batch
+            self._bulk_insert(batch_data)
+            total_committed += len(batch_data)
+
+            # Update progress - simple single line
+            batch_size_actual = len(batch_items)
+            processed_count += batch_size_actual
             if self.verbose:
-                total_time = time() - t
-                rate = total_items / total_time if total_time > 0 else 0
-                print(f"✅ Completed: {total_items} embeddings computed and {total_committed} items committed to database")
-                print(f"   Total time: {total_time:.2f}s | Rate: {rate:.1f} embeddings/sec")
+                elapsed = time() - t
+                rate = processed_count / elapsed if elapsed > 0 else 0
+                progress_pct = (processed_count / total_items) * 100
+                print(
+                    f"\rProgress: {processed_count}/{total_items} ({progress_pct:.1f}%) | {rate:.0f} texts/sec",
+                    end="",
+                    flush=True,
+                )
+
+        if self.verbose:
+            total_time = time() - t
+            rate = total_items / total_time if total_time > 0 else 0
+            print(
+                f"\n✅ Completed: {total_items} embeddings computed and {total_committed} items committed to database"
+            )
+            print(f"   Total time: {total_time:.2f}s | Rate: {rate:.1f} embeddings/sec")
 
     def __call__(self, texts: list[str], cache: bool = True) -> np.ndarray:
         assert isinstance(texts, list), "texts must be a list"
-        assert all(isinstance(t, str) for t in texts), "all elements in texts must be strings"
+        assert all(isinstance(t, str) for t in texts), (
+            "all elements in texts must be strings"
+        )
         return self.embeds(texts, cache)
 
     def _bulk_insert(self, data: list[tuple[str, str, bytes]]) -> None:
         """
         Perform bulk insert of embedding data with retry logic for multi-process safety.
-        
+
         Uses INSERT OR IGNORE to prevent race conditions where multiple processes
         might try to insert the same text hash. The first process to successfully
         insert wins, subsequent attempts are ignored. This ensures deterministic
@@ -607,7 +659,7 @@ class VectorCache:
 
         max_retries = 3
         base_delay = 0.1  # 100ms base delay
-        
+
         for attempt in range(max_retries + 1):
             try:
                 cursor = self.conn.executemany(
@@ -615,82 +667,34 @@ class VectorCache:
                     data,
                 )
                 self.conn.commit()
-                
+
                 # Check if some insertions were ignored due to existing entries
-                if self.verbose and cursor.rowcount < len(data):
-                    ignored_count = len(data) - cursor.rowcount
-                    if ignored_count > 0:
-                        print(f"ℹ️  {ignored_count}/{len(data)} embeddings already existed in cache (computed by another process)")
-                
+                # if self.verbose and cursor.rowcount < len(data):
+                # ignored_count = len(data) - cursor.rowcount
+                # if ignored_count > 0:
+                #     print(f"ℹ️  {ignored_count}/{len(data)} embeddings already existed in cache (computed by another process)")
+
                 return  # Success, exit the retry loop
-                
+
             except sqlite3.OperationalError as e:
                 if "database is locked" in str(e).lower() and attempt < max_retries:
                     # Exponential backoff: 0.1s, 0.2s, 0.4s
-                    delay = base_delay * (2 ** attempt)
+                    delay = base_delay * (2**attempt)
                     if self.verbose:
-                        print(f"⚠️  Database locked, retrying in {delay:.1f}s (attempt {attempt + 1}/{max_retries + 1})")
+                        print(
+                            f"⚠️  Database locked, retrying in {delay:.1f}s (attempt {attempt + 1}/{max_retries + 1})"
+                        )
                     import time
+
                     time.sleep(delay)
                     continue
                 else:
                     # Re-raise if not a lock error or max retries exceeded
                     raise
-            except Exception as e:
+            except Exception:
                 # Re-raise any other exceptions
                 raise
 
-    # def precompute_embeddings(self, texts: list[str]) -> None:
-    #     """
-    #     Precompute embeddings for a large list of texts efficiently.
-    #     This is optimized for bulk operations when you know all texts upfront.
-    #     """
-    #     assert isinstance(texts, list), "texts must be a list"
-    #     assert all(isinstance(t, str) for t in texts), "all elements in texts must be strings"
-    #     if not texts:
-    #         return
-
-    #     # Remove duplicates while preserving order
-    #     unique_texts = list(dict.fromkeys(texts))
-    #     if self.verbose:
-    #         print(f"Precomputing embeddings for {len(unique_texts)} unique texts...")
-
-    #     # Check which ones are already cached
-    #     hashes = [self._hash_text(t) for t in unique_texts]
-    #     existing_hashes = set()
-
-    #     # Bulk check for existing embeddings
-    #     chunk_size = self.config["sqlite_chunk_size"]
-    #     for i in range(0, len(hashes), chunk_size):
-    #         chunk = hashes[i : i + chunk_size]
-    #         placeholders = ",".join("?" * len(chunk))
-    #         rows = self._execute_with_retry(
-    #             f"SELECT hash FROM cache WHERE hash IN ({placeholders})",
-    #             chunk,
-    #         ).fetchall()
-    #         existing_hashes.update(h[0] for h in rows)
-
-    #     # Find missing texts
-    #     missing_items = [
-    #         (t, h) for t, h in zip(unique_texts, hashes) if h not in existing_hashes
-    #     ]
-
-    #     if not missing_items:
-    #         if self.verbose:
-    #             print("All texts already cached!")
-    #         return
-
-    #     if self.verbose:
-    #         print(f"Computing {len(missing_items)} missing embeddings...")
-        
-    #     # Process missing items with batches
-    #     missing_texts = [t for t, _ in missing_items]
-    #     missing_items_tupled = [(t, h) for t, h in zip(missing_texts, [self._hash_text(t) for t in missing_texts])]
-    #     hit_map_temp: dict[str, np.ndarray] = {}
-    #     self._process_missing_items_with_batches(missing_items_tupled, hit_map_temp)
-    #     if self.verbose:
-    #         print(f"Successfully cached {len(missing_items)} new embeddings!")
-
     def get_cache_stats(self) -> dict[str, int]:
         """Get statistics about the cache."""
         cursor = self._execute_with_retry("SELECT COUNT(*) FROM cache")
@@ -701,24 +705,27 @@ class VectorCache:
         """Clear all cached embeddings."""
         max_retries = 3
         base_delay = 0.1  # 100ms base delay
-        
+
         for attempt in range(max_retries + 1):
             try:
                 self.conn.execute("DELETE FROM cache")
                 self.conn.commit()
                 return  # Success
-                
+
             except sqlite3.OperationalError as e:
                 if "database is locked" in str(e).lower() and attempt < max_retries:
-                    delay = base_delay * (2 ** attempt)
+                    delay = base_delay * (2**attempt)
                     if self.verbose:
-                        print(f"⚠️  Database locked during clear, retrying in {delay:.1f}s (attempt {attempt + 1}/{max_retries + 1})")
+                        print(
+                            f"⚠️  Database locked during clear, retrying in {delay:.1f}s (attempt {attempt + 1}/{max_retries + 1})"
+                        )
                     import time
+
                     time.sleep(delay)
                     continue
                 else:
                     raise
-            except Exception as e:
+            except Exception:
                 raise
 
     def get_config(self) -> Dict[str, Any]:
@@ -730,7 +737,7 @@ class VectorCache:
             "db_path": str(self.db_path),
             "verbose": self.verbose,
             "lazy": self.lazy,
-            **self.config
+            **self.config,
         }
 
     def update_config(self, **kwargs) -> None:
@@ -744,17 +751,26 @@ class VectorCache:
                 self.lazy = value
             else:
                 raise ValueError(f"Unknown configuration parameter: {key}")
-        
+
         # Reset model if backend-specific parameters changed
         backend_params = {
-            "vllm": ["vllm_gpu_memory_utilization", "vllm_tensor_parallel_size", "vllm_dtype", 
-                    "vllm_trust_remote_code", "vllm_max_model_len"],
-            "transformers": ["transformers_device", "transformers_batch_size", 
-                           "transformers_normalize_embeddings", "transformers_trust_remote_code"],
+            "vllm": [
+                "vllm_gpu_memory_utilization",
+                "vllm_tensor_parallel_size",
+                "vllm_dtype",
+                "vllm_trust_remote_code",
+                "vllm_max_model_len",
+            ],
+            "transformers": [
+                "transformers_device",
+                "transformers_batch_size",
+                "transformers_normalize_embeddings",
+                "transformers_trust_remote_code",
+            ],
             "openai": ["api_key", "model_name"],
-            "processing": ["embedding_batch_size"]
+            "processing": ["embedding_batch_size"],
         }
-        
+
         if any(param in kwargs for param in backend_params.get(self.backend, [])):
             self._model = None  # Force reload on next use
             if self.backend == "openai":

speedy_utils/common/utils_cache.py

@@ -258,13 +258,13 @@ def _memory_memoize(
 
         with mem_lock:
             if name in mem_cache:
-                return mem_cache[name]  # type: ignore[return-value]
+                return mem_cache[name]
 
         result = func(*args, **kwargs)
 
         with mem_lock:
             if name not in mem_cache:
-                mem_cache[name] = result  # type: ignore[index]
+                mem_cache[name] = result
         return result
 
     return wrapper
@@ -292,7 +292,7 @@ def _async_memory_memoize(
 
         async with alock:
             if name in mem_cache:
-                return mem_cache[name]  # type: ignore[return-value]
+                return mem_cache[name]
             task = inflight.get(name)
             if task is None:
                 task = asyncio.create_task(func(*args, **kwargs))  # type: ignore[arg-type]
@@ -305,7 +305,7 @@ def _async_memory_memoize(
                 inflight.pop(name, None)
 
         with mem_lock:
-            mem_cache[name] = result  # type: ignore[index]
+            mem_cache[name] = result
         return result
 
     return wrapper
@@ -447,7 +447,7 @@ def both_memoize(
         # Memory first
         with mem_lock:
             if mem_key in mem_cache:
-                return mem_cache[mem_key]  # type: ignore[return-value]
+                return mem_cache[mem_key]
 
         # Disk next
         if sub_dir == "funcs":
@@ -468,7 +468,7 @@ def both_memoize(
 
         if disk_result is not None:
             with mem_lock:
-                mem_cache[mem_key] = disk_result  # type: ignore[index]
+                mem_cache[mem_key] = disk_result
             return disk_result
 
         # Miss: compute, then write both
@@ -477,7 +477,7 @@ def both_memoize(
             if not osp.exists(cache_path):
                 dump_json_or_pickle(result, cache_path)
         with mem_lock:
-            mem_cache[mem_key] = result  # type: ignore[index]
+            mem_cache[mem_key] = result
         return result
 
     return wrapper
@@ -506,7 +506,7 @@ def _async_both_memoize(
         # Memory
         async with alock:
             if mem_key in mem_cache:
-                return mem_cache[mem_key]  # type: ignore[return-value]
+                return mem_cache[mem_key]
 
         # Disk
         if sub_dir == "funcs":
@@ -526,7 +526,7 @@ def _async_both_memoize(
 
         if disk_result is not None:
             with mem_lock:
-                mem_cache[mem_key] = disk_result  # type: ignore[index]
+                mem_cache[mem_key] = disk_result
             return disk_result
 
         # Avoid duplicate async work for same key
@@ -550,7 +550,7 @@ def _async_both_memoize(
         await loop.run_in_executor(None, write_disk_cache)
 
         with mem_lock:
-            mem_cache[mem_key] = result  # type: ignore[index]
+            mem_cache[mem_key] = result
         return result
 
     return wrapper
@@ -561,9 +561,10 @@ def _async_both_memoize(
 # --------------------------------------------------------------------------------------
 
 
+# Define overloads to preserve exact type information
 @overload
 def memoize(
-    _func: Callable[P, R | Awaitable[R]],
+    _func: Callable[P, R],
     *,
     keys: Optional[list[str]] = ...,
     key: Optional[Callable[..., Any]] = ...,
@@ -572,7 +573,23 @@ def memoize(
     size: int = ...,
     ignore_self: bool = ...,
     verbose: bool = ...,
-) -> Callable[P, R | Awaitable[R]]: ...
+) -> Callable[P, R]: ...
+
+
+@overload
+def memoize(
+    _func: Callable[P, Awaitable[R]],
+    *,
+    keys: Optional[list[str]] = ...,
+    key: Optional[Callable[..., Any]] = ...,
+    cache_dir: str = ...,
+    cache_type: Literal["memory", "disk", "both"] = ...,
+    size: int = ...,
+    ignore_self: bool = ...,
+    verbose: bool = ...,
+) -> Callable[P, Awaitable[R]]: ...
+
+
 @overload
 def memoize(
     _func: None = ...,
@@ -585,6 +602,8 @@ def memoize(
     ignore_self: bool = ...,
     verbose: bool = ...,
 ) -> Callable[[Callable[P, R]], Callable[P, R]]: ...
+
+
 @overload
 def memoize( # type: ignore
     _func: None = ...,
@@ -635,24 +654,24 @@ def memoize(
 
         if cache_type == "memory":
             if is_async:
-                return _async_memory_memoize(target_func, size, keys, ignore_self, key)  # type: ignore[return-value]
-            return _memory_memoize(target_func, size, keys, ignore_self, key)  # type: ignore[return-value]
+                return _async_memory_memoize(target_func, size, keys, ignore_self, key)
+            return _memory_memoize(target_func, size, keys, ignore_self, key)
 
         if cache_type == "disk":
             if is_async:
                 return _async_disk_memoize(
                     target_func, keys, cache_dir, ignore_self, verbose, key
-                )  # type: ignore[return-value]
+                )
             return _disk_memoize(
                 target_func, keys, cache_dir, ignore_self, verbose, key
-            )  # type: ignore[return-value]
+            )
 
         # cache_type == "both"
         if is_async:
             return _async_both_memoize(
                 target_func, keys, cache_dir, ignore_self, size, key
-            )  # type: ignore[return-value]
-        return both_memoize(target_func, keys, cache_dir, ignore_self, size, key)  # type: ignore[return-value]
+            )
+        return both_memoize(target_func, keys, cache_dir, ignore_self, size, key)
 
     # Support both @memoize and @memoize(...)
     if _func is None:

speedy_utils/multi_worker/process.py

@@ -1,5 +1,10 @@
 # ray_multi_process.py
 import time, os, pickle, uuid, datetime, multiprocessing
+import datetime
+import os
+import pickle
+import time
+import uuid
 from pathlib import Path
 from typing import Any, Callable
 from tqdm import tqdm
@@ -12,11 +17,16 @@ try:
 except Exception:  # pragma: no cover
     ray = None  # type: ignore
     _HAS_RAY = False
+from typing import Any, Callable, Iterable
+
+import ray
 from fastcore.parallel import parallel
+from tqdm import tqdm
 
 
 # ─── 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")
@@ -27,6 +37,7 @@ def _build_cache_dir(func: Callable, items: list[Any]) -> Path:
     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:
@@ -38,12 +49,15 @@ def wrap_dump(func: Callable, cache_dir: Path | None):
         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
@@ -58,19 +72,22 @@ def ensure_ray(workers: int, pbar: tqdm | None = None):
             pbar.set_postfix_str(f"ray.init {workers} took {took:.2f}s")
         RAY_WORKER = workers
 
+
 # ─── main API ───────────────────────────────────────────────
 from typing import Literal
 
+
 def multi_process(
     func: Callable[[Any], Any],
-    items: list[Any] | None = None,
+    items: Iterable[Any] | None = None,
     *,
-    inputs: list[Any] | None = None,
+    inputs: Iterable[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", "safe"] | None = None,
+    backend: Literal["seq", "ray", "mp", "threadpool"] = "mp",
     # Additional optional knobs (accepted for compatibility)
     batch: int | None = None,
     ordered: bool | None = None,
@@ -97,8 +114,12 @@ def multi_process(
         backend = "ray" if _HAS_RAY else "mp"
 
     # unify items
+    # unify items and coerce to concrete list so we can use len() and
+    # iterate multiple times. This accepts ranges and other iterables.
     if items is None and inputs is not None:
         items = list(inputs)
+    if items is not None and not isinstance(items, list):
+        items = list(items)
     if items is None:
         raise ValueError("'items' or 'inputs' must be provided")
 
@@ -110,8 +131,9 @@ def multi_process(
     f_wrapped = wrap_dump(func, cache_dir)
 
     total = len(items)
-    with tqdm(total=total, desc=f"multi_process [{backend}]", disable=not progress) as pbar:
-
+    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")
@@ -147,12 +169,14 @@ def multi_process(
 
         # ---- fastcore backend ----
         if backend == "mp":
-            # Use threadpool instead of multiprocessing to avoid fork warnings
-            # in multi-threaded environments like pytest
-            results = parallel(f_wrapped, items, n_workers=workers, progress=progress, threadpool=True)
+            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)
+            results = parallel(
+                f_wrapped, items, n_workers=workers, progress=progress, threadpool=True
+            )
             return list(results)
         if backend == "safe":
             # Completely safe backend for tests - no multiprocessing, no external progress bars

{speedy_utils-1.1.19.dist-info → speedy_utils-1.1.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: speedy-utils
-Version: 1.1.19
+Version: 1.1.20
 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
@@ -18,26 +18,26 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.8
-Requires-Dist: aiohttp>=3.10.11
+Requires-Dist: aiohttp
 Requires-Dist: bump2version
 Requires-Dist: cachetools
 Requires-Dist: debugpy
 Requires-Dist: fastcore
 Requires-Dist: fastprogress
-Requires-Dist: freezegun>=1.5.1
+Requires-Dist: freezegun
 Requires-Dist: ipdb
 Requires-Dist: ipywidgets
-Requires-Dist: json-repair<0.31.0,>=0.25.0
+Requires-Dist: json-repair
 Requires-Dist: jupyterlab
 Requires-Dist: loguru
 Requires-Dist: matplotlib
 Requires-Dist: numpy
-Requires-Dist: openai>=1.106.0
-Requires-Dist: packaging<25,>=23.2
+Requires-Dist: openai
+Requires-Dist: packaging
 Requires-Dist: pandas
 Requires-Dist: pydantic
-Requires-Dist: pytest>=8.3.5
-Requires-Dist: ray>=2.36.1
+Requires-Dist: pytest
+Requires-Dist: ray
 Requires-Dist: requests
 Requires-Dist: scikit-learn
 Requires-Dist: tabulate

{speedy_utils-1.1.19.dist-info → speedy_utils-1.1.20.dist-info}/RECORD

@@ -9,7 +9,7 @@ llm_utils/lm/base_prompt_builder.py,sha256=OLqyxbA8QeYIVFzB9EqxUiE_P2p4_MD_Lq4WS
 llm_utils/lm/llm_task.py,sha256=kyBeMDJwW9ZWq5A_OMgE-ou9GQ0bk5c9lxXOvfo31R4,27915
 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=q1cj5tZOSEpvx4QhRNs37pVaFMpMViCdVtwRsoaXgeU,3054
+llm_utils/lm/openai_memoize.py,sha256=KToCcB_rhyrULxolnwMfQgl5GNrAeykePxuLS4hBjtc,3442
 llm_utils/lm/utils.py,sha256=a0KJj8vjT2fHKb7GKGNJjJHhKLThwpxIL7vnV9Fr3ZY,4584
 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
@@ -22,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=222LcmVJR0bFo0jRAJEG6e5ceWFfySmVbCxywScE6E4,33595
+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
@@ -34,17 +34,17 @@ speedy_utils/common/logger.py,sha256=a2iZx0eWyfi2-2X_H2QmfuA3tfR7_XSM7Nd0GdUnUOs
 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=8KPCWPUCm91HCH9kvV_gcshlxJl6m4tZ8yAKHhJCfUc,22445
+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_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=ouN65PbOhg0rOGUK7ATB7zXkRA993w9iiPDZ7nZ9g0w,6881
+speedy_utils/multi_worker/process.py,sha256=hRboiWDCiLmbVNqCuTl9Wop6wFIG1yxYYYemT2kfeX8,7265
 speedy_utils/multi_worker/thread.py,sha256=xhCPgJokCDjjPrWh6vUtCBlZgs3E6mM81WCAEKvZea0,19522
 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.19.dist-info/METADATA,sha256=AHlhLIK3CLwi6f_-_qJDS1lEfXYvvacZ1RHiV_Gfnb4,8094
-speedy_utils-1.1.19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-speedy_utils-1.1.19.dist-info/entry_points.txt,sha256=1rrFMfqvaMUE9hvwGiD6vnVh98kmgy0TARBj-v0Lfhs,244
-speedy_utils-1.1.19.dist-info/RECORD,,
+speedy_utils-1.1.20.dist-info/METADATA,sha256=c5wjCJMDRupz95YYIabcRcN18IVPMj4mihf6cbTmBF0,8028
+speedy_utils-1.1.20.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+speedy_utils-1.1.20.dist-info/entry_points.txt,sha256=1rrFMfqvaMUE9hvwGiD6vnVh98kmgy0TARBj-v0Lfhs,244
+speedy_utils-1.1.20.dist-info/RECORD,,