speedy-utils 1.1.0__py3-none-any.whl → 1.1.3__py3-none-any.whl

llm_utils/lm/async_lm.py

@@ -1,84 +1,10 @@
-"""
-# ============================================================================= #
-# ASYNCHRONOUS LANGUAGE MODEL WRAPPER WITH CONCURRENT EXECUTION SUPPORT
-# ============================================================================= #
-#
-# Title & Intent:
-# High-performance asynchronous language model interface for concurrent LLM operations
-#
-# High-level Summary:
-# This module provides an async drop-in replacement for the synchronous LM class, designed
-# for high-throughput applications requiring concurrent language model operations. It maintains
-# full API compatibility while adding async/await semantics, connection pooling, and efficient
-# resource management. The AsyncLM class supports batch processing, concurrent request handling,
-# and maintains the same caching and type safety guarantees as the synchronous version.
-#
-# Public API / Data Contracts:
-# • AsyncLM(model, temperature=0.0, max_tokens=2000, host="localhost", port=None, **kwargs) - Async wrapper class
-# • async AsyncLM.__call__(prompt=None, messages=None, response_format=str, cache=None, **kwargs) -> str | BaseModel
-# • async AsyncLM.list_models(port=None) -> List[str] - Enumerate available models
-# • async AsyncLM.count_tokens(messages, model=None) -> int - Token counting utility
-# • async AsyncLM.price(messages, model=None, response_tokens=0) -> float - Cost estimation
-# • AsyncLM.set_model(model_name) -> None - Runtime model switching (sync method)
-# • async AsyncLM.batch_call(requests) -> List[Union[str, BaseModel]] - Concurrent batch processing
-# • TModel = TypeVar("TModel", bound=BaseModel) - Generic type for structured responses
-# • Messages = List[ChatCompletionMessageParam] - Typed message format
-#
-# Invariants / Constraints:
-# • MUST be used within async context (asyncio event loop required)
-# • MUST provide either 'prompt' or 'messages' parameter, but not both
-# • MUST properly await all async method calls
-# • Connection pooling MUST handle concurrent requests efficiently
-# • MUST maintain thread safety across concurrent operations
-# • Rate limit handling MUST use async backoff without blocking event loop
-# • MUST preserve all synchronous LM class behaviors and constraints
-# • Resource cleanup MUST occur on context manager exit or explicit close
-#
-# Usage Example:
-# ```python
-# import asyncio
-# from llm_utils.lm.async_lm import AsyncLM
-# from pydantic import BaseModel
-#
-# class SummaryResponse(BaseModel):
-#     summary: str
-#     key_points: List[str]
-#     confidence: float
-#
-# async def main():
-#     # Single async call
-#     lm = AsyncLM(model="gpt-4o-mini", temperature=0.1)
-#     response = await lm(prompt="Summarize quantum computing")
-#     print(response)
-#
-#     # Concurrent batch processing
-#     texts = ["Text 1 to summarize", "Text 2 to summarize", "Text 3 to summarize"]
-#     tasks = [lm(prompt=f"Summarize: {text}", response_format=SummaryResponse) for text in texts]
-#     summaries = await asyncio.gather(*tasks)
-#
-#     for summary in summaries:
-#         print(f"Summary: {summary.summary}")
-#         print(f"Key points: {summary.key_points}")
-#
-# asyncio.run(main())
-# ```
-#
-# TODO & Future Work:
-# • Add async context manager support for automatic resource cleanup
-# • Implement connection pool size optimization based on usage patterns
-# • Add async streaming response support with async generators
-# • Optimize memory usage for large-scale concurrent operations
-# • Add async rate limiting with priority queuing
-#
-# ============================================================================= #
-"""
 
 import base64
 import hashlib
 import json
 import os
 from abc import ABC
-from functools import lru_cache
+from functools import cache, lru_cache
 from typing import (
     Any,
     Dict,
@@ -110,7 +36,7 @@ from openai.types.chat import (
 )
 from openai.types.model import Model
 from pydantic import BaseModel
-
+from pydantic import ValidationError
 from llm_utils.chat_format.display import get_conversation_one_turn
 
 # --------------------------------------------------------------------------- #
@@ -146,10 +72,13 @@ def _yellow(t):
     return _color(33, t)
 
 
-class ParsedOutput(TypedDict):
+TParsed = TypeVar("TParsed", bound=BaseModel)
+
+
+class ParsedOutput(TypedDict, Generic[TParsed]):
     messages: List
     completion: Any
-    parsed: BaseModel
+    parsed: TParsed
 
 
 class AsyncLM:
@@ -460,7 +389,7 @@ class AsyncLM:
     # ------------------------------------------------------------------ #
     async def parse(
         self,
-        response_model: Type[BaseModel],
+        response_model: Type[TParsed],
         instruction: Optional[str] = None,
         prompt: Optional[str] = None,
         messages: Optional[RawMsgs] = None,
@@ -470,7 +399,7 @@ class AsyncLM:
         max_tokens: Optional[int] = None,
         cache: Optional[bool] = True,
         **kwargs,
-    ) -> ParsedOutput:  # -> dict[str, Any]:
+    ) -> ParsedOutput[TParsed]:
         """Parse response using guided JSON generation."""
         if messages is None:
             assert instruction is not None, "Instruction must be provided."
@@ -513,6 +442,7 @@ class AsyncLM:
 
         use_cache = self.do_cache if cache is None else cache
         cache_key = None
+        completion = None
         if use_cache:
             cache_data = {
                 "messages": messages,
@@ -522,7 +452,7 @@ class AsyncLM:
             }
             cache_key = self._cache_key(cache_data, {}, response_model)
             completion = self._load_cache(cache_key)  # dict
-        else:
+        if not completion:
             completion = await self.client.chat.completions.create(
                 model=self.model,  # type: ignore
                 messages=messages,  # type: ignore
@@ -532,10 +462,12 @@ class AsyncLM:
             completion = completion.model_dump()
             if cache_key:
                 self._dump_cache(cache_key, completion)
-
+        assert isinstance(completion, dict), (
+            "Completion must be a dictionary with OpenAI response format."
+        )
         self.last_log = [prompt, messages, completion]
 
-        output = self._parse_complete_output(completion, response_model)
+        output = cast(TParsed, self._parse_complete_output(completion, response_model))
         full_messages = messages + [completion]
         return ParsedOutput(
             messages=full_messages,
@@ -555,7 +487,49 @@ class AsyncLM:
 
         content = completion["choices"][0]["message"]["content"]
         if not content:
-            raise ValueError("Empty content in response")
+            # Enhanced error for debugging: show input tokens and their count
+
+            # Try to extract tokens from the completion for debugging
+            input_tokens = None
+            try:
+                input_tokens = completion.get('usage', {}).get('prompt_tokens')
+            except Exception:
+                input_tokens = None
+
+            # Try to get the prompt/messages for tokenization
+            prompt = None
+            try:
+                prompt = completion.get('messages') or completion.get('prompt')
+            except Exception:
+                prompt = None
+
+            tokens_preview = ''
+            if prompt is not None:
+                try:
+                    tokenizer = get_tokenizer(self.model)
+                    if isinstance(prompt, list):
+                        prompt_text = '\n'.join(
+                            m.get('content', '') for m in prompt if isinstance(m, dict)
+                        )
+                    else:
+                        prompt_text = str(prompt)
+                    tokens = tokenizer.encode(prompt_text)
+                    n_tokens = len(tokens)
+                    first_100 = tokens[:100]
+                    last_100 = tokens[-100:] if n_tokens > 100 else []
+                    tokens_preview = (
+                        f'\nInput tokens: {n_tokens}'
+                        f'\nFirst 100 tokens: {first_100}'
+                        f'\nLast 100 tokens: {last_100}'
+                    )
+                except Exception as exc:
+                    tokens_preview = f'\n[Tokenization failed: {exc}]'
+
+            raise ValueError(
+                f'Empty content in response.'
+                f'\nInput tokens (if available): {input_tokens}'
+                f'{tokens_preview}'
+            )
 
         try:
             data = json.loads(content)
@@ -737,6 +711,7 @@ async def inspect_word_probs_async(lm, tokenizer, messages):
     """Async version of inspect_word_probs."""
 
     import numpy as np
+    
 
     async def compute_word_log_probs(
         tokenizer: Any,
@@ -894,12 +869,14 @@ class AsyncLLMTask(ABC, Generic[InputModelType, OutputModelType]):
     temperature: float = 0.6
     think: bool = False
     add_json_schema: bool = False
+    cache: bool = False
 
     async def __call__(
         self,
         data: BaseModel | dict,
         temperature: float = 0.1,
         cache: bool = False,
+        think: Optional[bool] = None,  # if not None, overrides self.think
     ) -> tuple[OutputModelType, List[Dict[str, Any]]]:
         # Get the input and output model types from the generic parameters
         type_args = getattr(self.__class__, "__orig_bases__", None)
@@ -940,9 +917,9 @@ class AsyncLLMTask(ABC, Generic[InputModelType, OutputModelType]):
             instruction=self.__doc__ or "",
             response_model=output_model,
             temperature=temperature or self.temperature,
-            think=self.think,
+            think=think if think is not None else self.think,
             add_json_schema_to_instruction=self.add_json_schema,
-            cache=cache,
+            cache=self.cache or cache,
         )
 
         return (

llm_utils/scripts/vllm_load_balancer.py

@@ -1,104 +1,183 @@
-"""
-# ============================================================================= #
-# VLLM LOAD BALANCER WITH HEALTH MONITORING AND DYNAMIC ROUTING
-# ============================================================================= #
-#
-# Title & Intent:
-# Production-ready TCP load balancer for vLLM model servers with health checks and connection management
-#
-# High-level Summary:
-# This module implements a high-performance load balancer specifically designed for vLLM model
-# serving infrastructure. It provides intelligent routing across multiple vLLM server instances,
-# continuous health monitoring, automatic failover, and connection pooling. The load balancer
-# uses async TCP proxying to handle concurrent requests efficiently while maintaining session
-# affinity and providing detailed metrics for monitoring and debugging.
-#
-# Public API / Data Contracts:
-# • LOAD_BALANCER_HOST = "0.0.0.0" - Load balancer bind address
-# • LOAD_BALANCER_PORT = 8008 - Load balancer listening port
-# • SCAN_TARGET_HOST = "localhost" - Target server host for health checks
-# • SCAN_PORT_START = 8140, SCAN_PORT_END = 8170 - Port range for server discovery
-# • start_load_balancer() -> None - Main entry point to start the service
-# • scan_for_healthy_servers() -> None - Background health monitoring task
-# • handle_client(reader, writer) -> None - Client connection handler
-# • relay_data(reader, writer, direction) -> None - Bidirectional data relay
-# • get_next_server() -> Optional[Tuple[str, int]] - Round-robin server selection
-#
-# Invariants / Constraints:
-# • MUST continuously monitor server health every SCAN_INTERVAL seconds
-# • MUST handle connection failures gracefully with automatic failover
-# • Health checks MUST complete within HEALTH_CHECK_TIMEOUT seconds
-# • MUST maintain connection counts for load balancing decisions
-# • Server availability MUST be updated atomically using async locks
-# • TCP connections MUST be properly closed on errors or completion
-# • MUST log all connection events and health status changes
-# • Round-robin selection MUST distribute load evenly across healthy servers
-#
-# Usage Example:
-# ```python
-# # Start the load balancer (blocking operation)
-# import asyncio
-# from llm_utils.scripts.vllm_load_balancer import start_load_balancer
-#
-# # Configure environment or modify constants as needed
-# LOAD_BALANCER_HOST = "0.0.0.0"
-# LOAD_BALANCER_PORT = 8008
-# SCAN_TARGET_HOST = "localhost"
-# SCAN_PORT_START = 8140
-# SCAN_PORT_END = 8150
-#
-# # Start the load balancer service
-# asyncio.run(start_load_balancer())
-#
-# # The service will:
-# # 1. Scan for healthy vLLM servers on ports 8140-8150
-# # 2. Accept client connections on port 8008
-# # 3. Route requests to healthy backend servers
-# # 4. Monitor server health continuously
-# # 5. Provide connection statistics
-# ```
-#
-# TODO & Future Work:
-# • Add weighted round-robin based on server capacity metrics
-# • Implement session affinity for stateful model interactions
-# • Add HTTP health check endpoints for better monitoring integration
-# • Support dynamic server registration and deregistration
-# • Add metrics export for Prometheus/Grafana monitoring
-# • Implement graceful shutdown with connection draining
-#
-# ============================================================================= #
-"""
+import argparse
+import sys
+import os
+import time
+from datetime import datetime
+from collections import defaultdict
 
 import asyncio
 import contextlib
 import random
-from collections import defaultdict
 
-import aiohttp  # <-- Import aiohttp
+import aiohttp
 from loguru import logger
 from tabulate import tabulate
 
 from speedy_utils import setup_logger
 
 setup_logger(min_interval=5)
-# --- Configuration ---
-LOAD_BALANCER_HOST = "0.0.0.0"
-LOAD_BALANCER_PORT = 8008
 
-SCAN_TARGET_HOST = "localhost"
-SCAN_PORT_START = 8140
-SCAN_PORT_END = 8170  # Inclusive
-SCAN_INTERVAL = 30
-# Timeout applies to the HTTP health check request now
-HEALTH_CHECK_TIMEOUT = 2  # Increased slightly for HTTP requests
+# --- CLI Argument Parsing ---
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="🚀 vLLM Load Balancer - High-Performance Async TCP/HTTP Load Balancer",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python vllm_load_balancer.py 8001 --ports 8140,8150,8160
+  python vllm_load_balancer.py 8080 --ports 8140,8150 --host 192.168.1.100
+  python vllm_load_balancer.py 8001 --ports 8140,8150 --status-interval 3
+
+Features:
+  • Real-time dashboard with color-coded status
+  • Automatic health checks and failover
+  • Least-connections load balancing
+  • Professional terminal interface
+  • Connection statistics and monitoring
+        """
+    )
+    parser.add_argument(
+        "port",
+        type=int,
+        help="Port for the load balancer to listen on (e.g., 8001)",
+    )
+    parser.add_argument(
+        "--ports",
+        type=str,
+        required=True,
+        help="Comma-separated list of backend ports to use (e.g., 8140,8150)",
+    )
+    parser.add_argument(
+        "--host",
+        type=str,
+        default="localhost",
+        help="Backend host (default: localhost)",
+    )
+    parser.add_argument(
+        "--status-interval",
+        type=int,
+        default=5,
+        help="Status print interval in seconds (default: 5)",
+    )
+    parser.add_argument(
+        "--health-timeout",
+        type=int,
+        default=2,
+        help="Health check timeout in seconds (default: 2)",
+    )
+    parser.add_argument(
+        "--stats-port",
+        type=int,
+        default=None,
+        help="Port for the HTTP stats dashboard (default: proxy port + 1)",
+    )
+    return parser.parse_args()
 
+# --- Configuration (populated from CLI) ---
+LOAD_BALANCER_HOST = "0.0.0.0"
+LOAD_BALANCER_PORT = 8008  # Will be overwritten by CLI
+STATS_PORT = 8009  # Will be overwritten by CLI
+BACKEND_HOST = "localhost"  # Will be overwritten by CLI
+BACKEND_PORTS = []  # Will be overwritten by CLI
 STATUS_PRINT_INTERVAL = 5
+HEALTH_CHECK_TIMEOUT = 2
 BUFFER_SIZE = 4096
 
 # --- Global Shared State ---
 available_servers = []
 connection_counts = defaultdict(int)
 state_lock = asyncio.Lock()
+start_time = None
+total_connections_served = 0
+current_active_connections = 0
+
+
+# --- Terminal Utilities ---
+def clear_terminal():
+    """Clear terminal screen with cross-platform support."""
+    if os.name == 'nt':  # Windows
+        os.system('cls')
+    else:  # Unix/Linux/MacOS
+        os.system('clear')
+
+
+def get_terminal_size():
+    """Get terminal dimensions."""
+    try:
+        columns, rows = os.get_terminal_size()
+        return columns, rows
+    except OSError:
+        return 80, 24  # Default fallback
+
+
+def format_uptime(start_time):
+    """Format uptime in a human-readable way."""
+    if not start_time:
+        return "Unknown"
+    
+    uptime_seconds = time.time() - start_time
+    hours = int(uptime_seconds // 3600)
+    minutes = int((uptime_seconds % 3600) // 60)
+    seconds = int(uptime_seconds % 60)
+    
+    if hours > 0:
+        return f"{hours}h {minutes}m {seconds}s"
+    elif minutes > 0:
+        return f"{minutes}m {seconds}s"
+    else:
+        return f"{seconds}s"
+
+
+def print_banner():
+    """Print a professional startup banner."""
+    columns, _ = get_terminal_size()
+    banner_width = min(columns - 4, 80)
+    
+    print("=" * banner_width)
+    print(f"{'🚀 vLLM Load Balancer':^{banner_width}}")
+    print(f"{'High-Performance Async TCP/HTTP Load Balancer':^{banner_width}}")
+    print("=" * banner_width)
+    print(f"Started at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print(f"Load Balancer Port: {LOAD_BALANCER_PORT}")
+    print(f"Backend Host: {BACKEND_HOST}")
+    print(f"Backend Ports: {', '.join(map(str, BACKEND_PORTS))}")
+    print(f"Health Check Interval: 10s (Timeout: {HEALTH_CHECK_TIMEOUT}s)")
+    print(f"Status Update Interval: {STATUS_PRINT_INTERVAL}s")
+    print("=" * banner_width)
+    print()
+
+
+# --- ANSI Color Codes ---
+class Colors:
+    RESET = '\033[0m'
+    BOLD = '\033[1m'
+    DIM = '\033[2m'
+    
+    # Foreground colors
+    BLACK = '\033[30m'
+    RED = '\033[31m'
+    GREEN = '\033[32m'
+    YELLOW = '\033[33m'
+    BLUE = '\033[34m'
+    MAGENTA = '\033[35m'
+    CYAN = '\033[36m'
+    WHITE = '\033[37m'
+    
+    # Bright colors
+    BRIGHT_BLACK = '\033[90m'
+    BRIGHT_RED = '\033[91m'
+    BRIGHT_GREEN = '\033[92m'
+    BRIGHT_YELLOW = '\033[93m'
+    BRIGHT_BLUE = '\033[94m'
+    BRIGHT_MAGENTA = '\033[95m'
+    BRIGHT_CYAN = '\033[96m'
+    BRIGHT_WHITE = '\033[97m'
+    
+    # Background colors
+    BG_RED = '\033[41m'
+    BG_GREEN = '\033[42m'
+    BG_YELLOW = '\033[43m'
+    BG_BLUE = '\033[44m'
 
 
 # --- Helper Functions --- (relay_data and safe_close_writer remain the same)
@@ -145,21 +224,17 @@ async def safe_close_writer(writer):
                 logger.debug(f"Error closing writer in context manager: {e}")
 
 
-# --- Server Scanning and Health Check (Modified) ---
-
 
+# --- Health Check for Provided Ports ---
 async def check_server_health(session, host, port):
     """Performs an HTTP GET request to the /health endpoint."""
     url = f"http://{host}:{port}/health"
     try:
-        # Use the provided aiohttp session to make the GET request
         async with session.get(url, timeout=HEALTH_CHECK_TIMEOUT) as response:
-            # Check for a successful status code (2xx range)
             if 200 <= response.status < 300:
                 logger.debug(
                     f"[{LOAD_BALANCER_PORT=}] Health check success for {url} (Status: {response.status})"
                 )
-                # Ensure the connection is released back to the pool
                 await response.release()
                 return True
             else:
@@ -172,61 +247,51 @@ async def check_server_health(session, host, port):
         logger.debug(f"Health check HTTP request timeout for {url}")
         return False
     except aiohttp.ClientConnectorError as e:
-        # Handles connection refused, DNS errors etc. - server likely down
         logger.debug(f"Health check connection error for {url}: {e}")
         return False
     except aiohttp.ClientError as e:
-        # Catch other potential client errors (e.g., invalid URL structure, too many redirects)
         logger.warning(f"Health check client error for {url}: {e}")
         return False
     except Exception as e:
-        # Catch any other unexpected errors during the check
         logger.error(f"Unexpected health check error for {url}: {e}")
         return False
 
 
 async def scan_and_update_servers():
-    """Periodically scans ports using HTTP /health check and updates available servers."""
+    """Periodically checks the provided backend ports and updates available servers."""
     global available_servers
     logger.debug(
-        f"Starting server scan task (HTTP GET /health on Ports {SCAN_PORT_START}-{SCAN_PORT_END} every {SCAN_INTERVAL}s)"
+        f"Starting server scan task (HTTP GET /health on ports {BACKEND_PORTS} every 10s)"
     )
     while True:
         try:
             current_scan_results = []
             scan_tasks = []
-            ports_to_scan = range(SCAN_PORT_START, SCAN_PORT_END + 1)
+            ports_to_scan = BACKEND_PORTS
 
-            # Create ONE aiohttp session for all checks within this scan cycle for efficiency
             async with aiohttp.ClientSession() as session:
-                # Create health check tasks for all ports, passing the shared session
                 for port in ports_to_scan:
                     task = asyncio.create_task(
-                        check_server_health(session, SCAN_TARGET_HOST, port)
+                        check_server_health(session, BACKEND_HOST, port)
                     )
                     scan_tasks.append((task, port))
 
-                # Wait for all health checks to complete
-                # return_exceptions=True prevents gather from stopping if one check fails
                 await asyncio.gather(
                     *(task for task, port in scan_tasks), return_exceptions=True
                 )
 
-                # Collect results from completed tasks
                 for task, port in scan_tasks:
                     try:
-                        # Check if task finished, wasn't cancelled, and returned True
                         if (
                             task.done()
                             and not task.cancelled()
                             and task.result() is True
                         ):
-                            current_scan_results.append((SCAN_TARGET_HOST, port))
+                            current_scan_results.append((BACKEND_HOST, port))
                     except Exception as e:
                         logger.error(
                             f"Error retrieving health check result for port {port}: {e}"
                         )
-            # --- Update Shared State (Locked) ---
             async with state_lock:
                 previous_servers = set(available_servers)
                 current_set = set(current_scan_results)
@@ -263,9 +328,9 @@ async def scan_and_update_servers():
             break
         except Exception as e:
             logger.error(f"Error in scan_and_update_servers loop: {e}")
-            await asyncio.sleep(SCAN_INTERVAL / 2)  # Avoid tight loop on error
+            await asyncio.sleep(5)  # Avoid tight loop on error
 
-        await asyncio.sleep(SCAN_INTERVAL)
+        await asyncio.sleep(10)
 
 
 # --- Core Load Balancer Logic (handle_client remains the same) ---
@@ -279,6 +344,7 @@ async def handle_client(client_reader, client_writer):
     backend_writer = None
     server_selected = False
 
+    global total_connections_served, current_active_connections
     try:
         # --- Select Backend Server (Least Connections from Available) ---
         selected_server = None
@@ -310,6 +376,12 @@ async def handle_client(client_reader, client_writer):
                 connection_counts[selected_server] += 1
                 backend_server = selected_server
                 server_selected = True
+                
+                # Update global statistics
+                global total_connections_served, current_active_connections
+                total_connections_served += 1
+                current_active_connections += 1
+                
                 logger.info(
                     f"Routing {client_addr} to {backend_server} (Current connections: {connection_counts[backend_server]})"
                 )
@@ -408,6 +480,7 @@ async def handle_client(client_reader, client_writer):
                 if backend_server in connection_counts:
                     if connection_counts[backend_server] > 0:
                         connection_counts[backend_server] -= 1
+                        current_active_connections = max(0, current_active_connections - 1)
                         logger.info(
                             f"Connection closed for {client_addr}. Backend {backend_server} connections: {connection_counts[backend_server]}"
                         )
@@ -418,92 +491,392 @@ async def handle_client(client_reader, client_writer):
                         connection_counts[backend_server] = 0
 
 
-# --- Status Reporting Task (print_status_periodically remains the same) ---
+
+# --- Status Reporting Task ---
 async def print_status_periodically():
-    """Periodically prints the connection status based on available servers."""
+    """Periodically displays a professional real-time status dashboard."""
     while True:
         await asyncio.sleep(STATUS_PRINT_INTERVAL)
-        async with state_lock:
-            headers = ["Backend Server", "Host", "Port", "Active Connections", "Status"]
-            table_data = []
-            total_connections = 0
-            current_available = available_servers[:]
-            current_counts = connection_counts.copy()
-
-        if not current_available:
-            # clear terminal and print status
-            print("\033[H\033[J", end="")  # Clear terminal
-            print("\n----- Load Balancer Status -----")
-            print("No backend servers currently available (failed /health check).")
-            print("------------------------------\n")
-            continue
-
-        for server in current_available:
-            host, port = server
-            count = current_counts.get(server, 0)
-            table_data.append([f"{host}:{port}", host, port, count, "Available"])
-            total_connections += count
-
-        table_data.sort(key=lambda row: (row[1], row[2]))
+        await display_status_dashboard()
+
+
+async def display_status_dashboard():
+    """Display a professional real-time status dashboard."""
+    global current_active_connections, total_connections_served
+
+    async with state_lock:
+        current_available = set(available_servers)
+        current_counts = connection_counts.copy()
+
+    # Clear terminal for fresh display
+    clear_terminal()
+
+    # Get terminal dimensions for responsive layout
+    columns, rows = get_terminal_size()
+    dash_width = min(columns - 4, 100)
+    
+    # Header with title and timestamp
+    current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    print(f"{Colors.BOLD}{Colors.BRIGHT_CYAN}{'=' * dash_width}{Colors.RESET}")
+    print(f"{Colors.BOLD}{Colors.BRIGHT_CYAN}{'🚀 vLLM Load Balancer Dashboard':^{dash_width}}{Colors.RESET}")
+    print(f"{Colors.BRIGHT_CYAN}{'Real-time Status & Monitoring':^{dash_width}}{Colors.RESET}")
+    print(f"{Colors.BOLD}{Colors.BRIGHT_CYAN}{'=' * dash_width}{Colors.RESET}")
+    print()
+    
+    # System Information Section
+    uptime = format_uptime(start_time)
+    print(f"{Colors.BOLD}{Colors.BRIGHT_WHITE}📊 System Information{Colors.RESET}")
+    print(f"{Colors.BRIGHT_BLACK}{'─' * (dash_width // 2)}{Colors.RESET}")
+    print(f"{Colors.YELLOW}🕐 Current Time:{Colors.RESET} {current_time}")
+    print(f"{Colors.YELLOW}⏱️  Uptime:{Colors.RESET} {uptime}")
+    print(f"{Colors.YELLOW}🌐 Load Balancer:{Colors.RESET} {LOAD_BALANCER_HOST}:{LOAD_BALANCER_PORT}")
+    print(f"{Colors.YELLOW}🎯 Backend Host:{Colors.RESET} {BACKEND_HOST}")
+    print(f"{Colors.YELLOW}🔧 Configured Ports:{Colors.RESET} {', '.join(map(str, BACKEND_PORTS))}")
+    print()
+    
+    # Connection Statistics Section
+    print(f"{Colors.BOLD}{Colors.BRIGHT_WHITE}📈 Connection Statistics{Colors.RESET}")
+    print(f"{Colors.BRIGHT_BLACK}{'─' * (dash_width // 2)}{Colors.RESET}")
+    print(f"{Colors.GREEN}📊 Total Connections Served:{Colors.RESET} {total_connections_served:,}")
+    print(f"{Colors.GREEN}🔗 Currently Active:{Colors.RESET} {current_active_connections}")
+    print(f"{Colors.GREEN}⚡ Health Check Timeout:{Colors.RESET} {HEALTH_CHECK_TIMEOUT}s")
+    print(f"{Colors.GREEN}🔄 Status Update Interval:{Colors.RESET} {STATUS_PRINT_INTERVAL}s")
+    print()
+    
+    # Backend Servers Status
+    print(f"{Colors.BOLD}{Colors.BRIGHT_WHITE}Backend Servers Status{Colors.RESET}")
+    print(f"{Colors.BRIGHT_BLACK}{'─' * (dash_width // 2)}{Colors.RESET}")
+
+    headers = [
+        f"{Colors.BOLD}Server{Colors.RESET}",
+        f"{Colors.BOLD}Host{Colors.RESET}",
+        f"{Colors.BOLD}Port{Colors.RESET}",
+        f"{Colors.BOLD}Active Conn.{Colors.RESET}",
+        f"{Colors.BOLD}Status{Colors.RESET}"
+    ]
+
+    table_data = []
+    total_backend_connections = 0
+
+    for port in BACKEND_PORTS:
+        server = (BACKEND_HOST, port)
+        is_online = server in current_available
+        count = current_counts.get(server, 0) if is_online else 0
+        total_backend_connections += count
+
+        # Color-code connection count based on load
+        if count == 0:
+            conn_display = f"{Colors.DIM}0{Colors.RESET}"
+        elif count < 5:
+            conn_display = f"{Colors.GREEN}{count}{Colors.RESET}"
+        elif count < 10:
+            conn_display = f"{Colors.YELLOW}{count}{Colors.RESET}"
+        else:
+            conn_display = f"{Colors.RED}{count}{Colors.RESET}"
+
+        status_display = (
+            f"{Colors.BG_GREEN}{Colors.BLACK} ONLINE {Colors.RESET}"
+            if is_online
+            else f"{Colors.BG_RED}{Colors.WHITE} OFFLINE {Colors.RESET}"
+        )
+
+        table_data.append([
+            f"{Colors.CYAN}{BACKEND_HOST}:{port}{Colors.RESET}",
+            BACKEND_HOST,
+            str(port),
+            conn_display,
+            status_display
+        ])
 
-        try:
-            table = tabulate(table_data, headers=headers, tablefmt="grid")
-            print("\n----- Load Balancer Status -----")
-            print(
-                f"Scanning Ports: {SCAN_PORT_START}-{SCAN_PORT_END} on {SCAN_TARGET_HOST} (using /health endpoint)"
-            )
-            print(
-                f"Scan Interval: {SCAN_INTERVAL}s | Health Check Timeout: {HEALTH_CHECK_TIMEOUT}s"
-            )
-            print(table)
-            print(
-                f"Total Active Connections (on available servers): {total_connections}"
-            )
-            print("------------------------------\n")
-        except Exception as e:
-            logger.error(f"Error printing status table: {e}")
-
-
-# --- Main Execution (main remains the same) ---
-async def main():
-    scan_task = asyncio.create_task(scan_and_update_servers())
-    status_task = asyncio.create_task(print_status_periodically())
+    try:
+        table = tabulate(table_data, headers=headers, tablefmt="fancy_grid")
+        print(table)
+        print()
+
+        # Summary metrics
+        online_count = sum(1 for port in BACKEND_PORTS if (BACKEND_HOST, port) in current_available)
+        avg_connections = total_backend_connections / online_count if online_count else 0
+        print(f"{Colors.BOLD}{Colors.BRIGHT_WHITE}📋 Summary{Colors.RESET}")
+        print(f"{Colors.BRIGHT_BLACK}{'─' * (dash_width // 4)}{Colors.RESET}")
+        print(f"{Colors.MAGENTA}🟢 Available Servers:{Colors.RESET} {online_count} / {len(BACKEND_PORTS)}")
+        print(f"{Colors.MAGENTA}📊 Total Backend Connections:{Colors.RESET} {total_backend_connections}")
+        print(f"{Colors.MAGENTA}📈 Average Load per Online Server:{Colors.RESET} {avg_connections:.1f}")
 
-    server = await asyncio.start_server(
-        handle_client, LOAD_BALANCER_HOST, LOAD_BALANCER_PORT
+    except Exception as e:
+        logger.error(f"Error displaying status table: {e}")
+        print(f"{Colors.RED}Error displaying server table: {e}{Colors.RESET}")
+
+    # Footer with refresh info
+    print()
+    print(f"{Colors.BRIGHT_BLACK}{'─' * dash_width}{Colors.RESET}")
+    print(f"{Colors.DIM}🔄 Auto-refresh every {STATUS_PRINT_INTERVAL}s | Press Ctrl+C to stop{Colors.RESET}")
+    print(f"{Colors.BRIGHT_BLACK}{'─' * dash_width}{Colors.RESET}")
+    print()
+
+
+
+# --- HTTP Stats Server ---
+from aiohttp import web
+
+async def stats_json(request):
+    async with state_lock:
+        # Build a list of all configured servers, with status and connections
+        all_servers = []
+        available_set = set(available_servers)
+        for port in BACKEND_PORTS:
+            server = (BACKEND_HOST, port)
+            is_online = server in available_set
+            all_servers.append({
+                "host": BACKEND_HOST,
+                "port": port,
+                "active_connections": connection_counts.get(server, 0) if is_online else 0,
+                "status": "ONLINE" if is_online else "OFFLINE",
+            })
+        stats = {
+            "time": datetime.now().isoformat(),
+            "uptime": format_uptime(start_time),
+            "load_balancer_host": LOAD_BALANCER_HOST,
+            "load_balancer_port": LOAD_BALANCER_PORT,
+            "backend_host": BACKEND_HOST,
+            "backend_ports": BACKEND_PORTS,
+            "total_connections_served": total_connections_served,
+            "current_active_connections": current_active_connections,
+            "health_check_timeout": HEALTH_CHECK_TIMEOUT,
+            "status_update_interval": STATUS_PRINT_INTERVAL,
+            "servers": all_servers,
+        }
+    return web.json_response(stats)
+
+async def stats_page(request):
+    # High-quality HTML dashboard with auto-refresh and charts
+    return web.Response(
+        content_type="text/html",
+        text="""
+<!DOCTYPE html>
+<html lang='en'>
+<head>
+    <meta charset='UTF-8'>
+    <meta name='viewport' content='width=device-width, initial-scale=1.0'>
+    <title>vLLM Load Balancer Stats</title>
+    <link rel='preconnect' href='https://fonts.googleapis.com'>
+    <link rel='preconnect' href='https://fonts.gstatic.com' crossorigin>
+    <link href='https://fonts.googleapis.com/css2?family=Roboto:wght@400;700&display=swap' rel='stylesheet'>
+    <script src='https://cdn.jsdelivr.net/npm/chart.js'></script>
+    <style>
+        body { font-family: 'Roboto', sans-serif; background: #181c20; color: #f3f3f3; margin: 0; }
+        .container { max-width: 900px; margin: 32px auto; background: #23272b; border-radius: 12px; box-shadow: 0 2px 16px #0008; padding: 32px; }
+        h1 { text-align: center; font-size: 2.2em; margin-bottom: 0.2em; }
+        .subtitle { text-align: center; color: #7fd7ff; margin-bottom: 1.5em; }
+        .stats-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 24px; margin-bottom: 2em; }
+        .stat-box { background: #20232a; border-radius: 8px; padding: 18px 24px; text-align: center; }
+        .stat-label { color: #7fd7ff; font-size: 1.1em; margin-bottom: 0.2em; }
+        .stat-value { font-size: 2em; font-weight: bold; }
+        .server-table { width: 100%; border-collapse: collapse; margin-top: 1.5em; }
+        .server-table th, .server-table td { padding: 10px 8px; text-align: center; }
+        .server-table th { background: #2c313a; color: #7fd7ff; }
+        .server-table tr:nth-child(even) { background: #23272b; }
+        .server-table tr:nth-child(odd) { background: #1b1e22; }
+        .status-online { color: #00e676; font-weight: bold; }
+        .status-offline { color: #ff5252; font-weight: bold; }
+        .chart-container { background: #20232a; border-radius: 8px; padding: 18px 24px; margin-top: 2em; }
+        @media (max-width: 700px) { .stats-grid { grid-template-columns: 1fr; } }
+    </style>
+</head>
+<body>
+    <div class='container'>
+        <h1>🚀 vLLM Load Balancer</h1>
+        <div class='subtitle'>Live Stats Dashboard</div>
+        <div class='stats-grid' id='statsGrid'>
+            <!-- Stats will be injected here -->
+        </div>
+        <div class='chart-container'>
+            <canvas id='connChart' height='80'></canvas>
+        </div>
+        <table class='server-table' id='serverTable'>
+            <thead>
+                <tr>
+                    <th>Backend Server</th>
+                    <th>Host</th>
+                    <th>Port</th>
+                    <th>Active Connections</th>
+                    <th>Status</th>
+                </tr>
+            </thead>
+            <tbody></tbody>
+        </table>
+        <div style='text-align:center; margin-top:2em; color:#888;'>
+            <span id='lastUpdate'></span> | Auto-refreshing every 1s
+        </div>
+    </div>
+    <script>
+        let connChart;
+        let connHistory = [];
+        let timeHistory = [];
+        async function fetchStats() {
+            const res = await fetch('/stats.json');
+            return await res.json();
+        }
+        function updateStats(stats) {
+            document.getElementById('lastUpdate').textContent = 'Last update: ' + new Date(stats.time).toLocaleTimeString();
+            // Stats grid
+            document.getElementById('statsGrid').innerHTML = `
+                <div class='stat-box'><div class='stat-label'>Uptime</div><div class='stat-value'>${stats.uptime}</div></div>
+                <div class='stat-box'><div class='stat-label'>Total Connections</div><div class='stat-value'>${stats.total_connections_served}</div></div>
+                <div class='stat-box'><div class='stat-label'>Active Connections</div><div class='stat-value'>${stats.current_active_connections}</div></div>
+                <div class='stat-box'><div class='stat-label'>Configured Servers</div><div class='stat-value'>${stats.servers.length}</div></div>
+            `;
+            // Server table
+            let tbody = document.querySelector('#serverTable tbody');
+            tbody.innerHTML = '';
+            for (const s of stats.servers) {
+                tbody.innerHTML += `<tr>
+                    <td>${s.host}:${s.port}</td>
+                    <td>${s.host}</td>
+                    <td>${s.port}</td>
+                    <td>${s.active_connections}</td>
+                    <td class='${s.status === "ONLINE" ? "status-online" : "status-offline"}'>${s.status}</td>
+                </tr>`;
+            }
+            // Chart (only count online servers for active connections)
+            connHistory.push(stats.current_active_connections);
+            timeHistory.push(new Date(stats.time).toLocaleTimeString());
+            if (connHistory.length > 60) { connHistory.shift(); timeHistory.shift(); }
+            if (!connChart) {
+                connChart = new Chart(document.getElementById('connChart').getContext('2d'), {
+                    type: 'line',
+                    data: {
+                        labels: timeHistory,
+                        datasets: [{
+                            label: 'Active Connections',
+                            data: connHistory,
+                            borderColor: '#7fd7ff',
+                            backgroundColor: 'rgba(127,215,255,0.1)',
+                            tension: 0.3,
+                            fill: true,
+                            pointRadius: 0
+                        }]
+                    },
+                    options: {
+                        plugins: { legend: { display: false } },
+                        scales: {
+                            x: { display: false },
+                            y: { beginAtZero: true, grid: { color: '#333' }, ticks: { color: '#7fd7ff' } }
+                        },
+                        animation: false,
+                        responsive: true,
+                        maintainAspectRatio: false
+                    }
+                });
+            } else {
+                connChart.data.labels = timeHistory;
+                connChart.data.datasets[0].data = connHistory;
+                connChart.update();
+            }
+        }
+        async function refresh() {
+            try {
+                const stats = await fetchStats();
+                updateStats(stats);
+            } catch (e) {
+                document.getElementById('lastUpdate').textContent = 'Error fetching stats';
+            }
+            setTimeout(refresh, 1000);
+        }
+        refresh();
+    </script>
+</body>
+</html>
+            """
     )
 
-    addrs = ", ".join(str(sock.getsockname()) for sock in server.sockets)
-    logger.info(f"Load balancer serving on {addrs}")
-    logger.info(
-        f"Dynamically discovering servers via HTTP /health on {SCAN_TARGET_HOST}:{SCAN_PORT_START}-{SCAN_PORT_END}"
-    )
+async def start_stats_server(loop):
+        app = web.Application()
+        app.router.add_get('/stats', stats_page)
+        app.router.add_get('/stats.json', stats_json)
+        runner = web.AppRunner(app)
+        await runner.setup()
+        site = web.TCPSite(runner, LOAD_BALANCER_HOST, STATS_PORT)
+        await site.start()
+        logger.info(f"Stats HTTP server running at http://{LOAD_BALANCER_HOST}:{STATS_PORT}/stats")
 
-    async with server:
-        try:
-            await server.serve_forever()
-        except asyncio.CancelledError:
-            logger.info("Load balancer server shutting down.")
-        finally:
-            logger.info("Cancelling background tasks...")
-            scan_task.cancel()
-            status_task.cancel()
+async def main():
+        global start_time
+        start_time = time.time()
+        clear_terminal()
+        print_banner()
+
+        # Start background tasks
+        scan_task = asyncio.create_task(scan_and_update_servers())
+        status_task = asyncio.create_task(print_status_periodically())
+
+        # Start HTTP stats server (on STATS_PORT)
+        loop = asyncio.get_running_loop()
+        await start_stats_server(loop)
+
+        # Start TCP server (on LOAD_BALANCER_PORT)
+        server = await asyncio.start_server(
+            handle_client, LOAD_BALANCER_HOST, LOAD_BALANCER_PORT
+        )
+
+        addrs = ", ".join(str(sock.getsockname()) for sock in server.sockets)
+        logger.info(f"Load balancer serving on {addrs}")
+        logger.info(
+            f"Configured backend ports: {BACKEND_PORTS} on host {BACKEND_HOST}"
+        )
+        print(f"{Colors.BRIGHT_GREEN}✅ Load balancer started successfully!{Colors.RESET}")
+        print(f"{Colors.BRIGHT_GREEN}🌐 Proxy listening on: {addrs}{Colors.RESET}")
+        print(f"{Colors.BRIGHT_GREEN}📊 Stats dashboard: http://localhost:{STATS_PORT}/stats{Colors.RESET}")
+        print(f"{Colors.YELLOW}🔍 Scanning backend servers...{Colors.RESET}")
+        print()
+        await asyncio.sleep(2)
+
+        async with server:
             try:
-                await asyncio.gather(scan_task, status_task, return_exceptions=True)
+                await server.serve_forever()
             except asyncio.CancelledError:
-                pass
-            logger.info("Background tasks finished.")
-
+                print(f"\n{Colors.YELLOW}🛑 Shutdown signal received...{Colors.RESET}")
+                logger.info("Load balancer server shutting down.")
+            except KeyboardInterrupt:
+                print(f"\n{Colors.YELLOW}🛑 Shutdown requested by user...{Colors.RESET}")
+                logger.info("Shutdown requested by user.")
+            finally:
+                print(f"{Colors.CYAN}🔄 Cleaning up background tasks...{Colors.RESET}")
+                logger.info("Cancelling background tasks...")
+                scan_task.cancel()
+                status_task.cancel()
+                try:
+                    await asyncio.gather(scan_task, status_task, return_exceptions=True)
+                except asyncio.CancelledError:
+                    pass
+                print(f"{Colors.BRIGHT_GREEN}✅ Shutdown complete. Goodbye!{Colors.RESET}")
+                logger.info("Background tasks finished.")
 
 def run_load_balancer():
-    # Make sure to install aiohttp: pip install aiohttp
+    global LOAD_BALANCER_PORT, BACKEND_PORTS, BACKEND_HOST, STATUS_PRINT_INTERVAL, HEALTH_CHECK_TIMEOUT, STATS_PORT
+    args = parse_args()
+    LOAD_BALANCER_PORT = args.port
+    BACKEND_HOST = args.host
+    BACKEND_PORTS = [int(p.strip()) for p in args.ports.split(",") if p.strip()]
+    STATUS_PRINT_INTERVAL = args.status_interval
+    HEALTH_CHECK_TIMEOUT = args.health_timeout
+    if args.stats_port is not None:
+        STATS_PORT = args.stats_port
+    else:
+        STATS_PORT = LOAD_BALANCER_PORT + 1
+    if not BACKEND_PORTS:
+        print(f"{Colors.BG_RED}{Colors.WHITE} ❌ ERROR {Colors.RESET}")
+        print(f"{Colors.RED}No backend ports specified. Use --ports 8140,8150 ...{Colors.RESET}")
+        logger.critical("No backend ports specified. Use --ports 8140,8150 ...")
+        sys.exit(1)
     try:
         asyncio.run(main())
     except KeyboardInterrupt:
-        logger.info("Shutdown requested by user.")
+        # This is handled in the main() function now
+        pass
     except Exception as e:
+        print(f"\n{Colors.BG_RED}{Colors.WHITE} ❌ CRITICAL ERROR {Colors.RESET}")
+        print(f"{Colors.RED}Critical error in main execution: {e}{Colors.RESET}")
         logger.critical(f"Critical error in main execution: {e}")
 
-
 if __name__ == "__main__":
     run_load_balancer()

{speedy_utils-1.1.0.dist-info → speedy_utils-1.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: speedy-utils
-Version: 1.1.0
+Version: 1.1.3
 Summary: Fast and easy-to-use package for data science
 Author: AnhVTH
 Author-email: anhvth.226@gmail.com

{speedy_utils-1.1.0.dist-info → speedy_utils-1.1.3.dist-info}/RECORD

@@ -5,13 +5,13 @@ llm_utils/chat_format/transform.py,sha256=8TZhvUS5DrjUeMNtDIuWY54B_QZ7jjpXEL9c8F
 llm_utils/chat_format/utils.py,sha256=xTxN4HrLHcRO2PfCTR43nH1M5zCa7v0kTTdzAcGkZg0,1229
 llm_utils/group_messages.py,sha256=8CU9nKOja3xeuhdrX5CvYVveSqSKb2zQ0eeNzA88aTQ,3621
 llm_utils/lm/__init__.py,sha256=rX36_MsnekM5GHwWS56XELbm4W5x2TDwnPERDTfo0eU,194
-llm_utils/lm/async_lm.py,sha256=kiWEecrkCTTQFlQj5JiHNziFeLOF1-7G_2xC2Dra1bw,35806
+llm_utils/lm/async_lm.py,sha256=eTyI9x4iZc4ZhYdwNadTYap5HgBJygiV_EBDZ-Og1cQ,34357
 llm_utils/lm/chat_html.py,sha256=FkGo0Dv_nAHYBMZzXfMu_bGQKaCx302goh3XaT-_ETc,8674
 llm_utils/lm/lm_json.py,sha256=fMt42phzFV2f6ulrtWcDXsWHi8WcG7gGkCzpIq8VSSM,1975
 llm_utils/lm/sync_lm.py,sha256=ANw_m5KiWcRwwoeQ5no6dzPFLc6j9o2oEcJtkMKqrn8,34640
 llm_utils/lm/utils.py,sha256=gUejbVZPYg97g4ftYEptYN52WhH3TAKOFW81sjLvi08,4585
 llm_utils/scripts/README.md,sha256=yuOLnLa2od2jp4wVy3rV0rESeiV3o8zol5MNMsZx0DY,999
-llm_utils/scripts/vllm_load_balancer.py,sha256=GjMdoZrdT9cSLos0qSdkLg2dwZgW1enAMsD3aTZAfNs,20845
+llm_utils/scripts/vllm_load_balancer.py,sha256=zz5aTaYwy5tYrv2RIhrizrGP-PnPAohgrl9kQvvJywA,35091
 llm_utils/scripts/vllm_serve.py,sha256=4NaqpVs7LBvxtvTCMPsNCAOfqiWkKRttxWMmWY7SitA,14729
 speedy_utils/__init__.py,sha256=YCpiReW22zG4KkQXQe6V9BQ8bn7PtiXolOaW_iL8T4M,5734
 speedy_utils/all.py,sha256=t-HKzDmhF1MTFnmq7xRnPs5nFG_aZaLH9Ua0RM6nQ9Y,4855
@@ -31,7 +31,7 @@ speedy_utils/multi_worker/thread.py,sha256=u_hTwXh7_FciMa5EukdEA1fDCY_vUC4moDceB
 speedy_utils/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 speedy_utils/scripts/mpython.py,sha256=73PHm1jqbCt2APN4xuNjD0VDKwzOj4EZsViEMQiZU2g,3853
 speedy_utils/scripts/openapi_client_codegen.py,sha256=f2125S_q0PILgH5dyzoKRz7pIvNEjCkzpi4Q4pPFRZE,9683
-speedy_utils-1.1.0.dist-info/METADATA,sha256=h1Alzm4q92GSiw5GNZWn6d8sHaSJS4X8RTMXStjkqHY,7441
-speedy_utils-1.1.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-speedy_utils-1.1.0.dist-info/entry_points.txt,sha256=T1t85jwx8fK6m5msdkBGIXH5R5Kd0zSL0S6erXERPzg,237
-speedy_utils-1.1.0.dist-info/RECORD,,
+speedy_utils-1.1.3.dist-info/METADATA,sha256=zTlCW23Gcdxio26wZ9L5FeWUsrvg5NOkGA0TPFQWRI8,7441
+speedy_utils-1.1.3.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+speedy_utils-1.1.3.dist-info/entry_points.txt,sha256=T1t85jwx8fK6m5msdkBGIXH5R5Kd0zSL0S6erXERPzg,237
+speedy_utils-1.1.3.dist-info/RECORD,,