flexllm 0.3.3__py3-none-any.whl

flexllm/utils/core.py

@@ -0,0 +1,41 @@
+"""Core utilities for flexllm"""
+
+from functools import wraps
+import asyncio
+import logging
+
+
+def async_retry(
+    retry_times: int = 3,
+    retry_delay: float = 1.0,
+    exceptions: tuple = (Exception,),
+    logger=None,
+):
+    """
+    Async retry decorator
+
+    Args:
+        retry_times: Maximum retry count
+        retry_delay: Delay between retries (seconds)
+        exceptions: Exception types to retry on
+        logger: Logger instance
+    """
+    if logger is None:
+        logger = logging.getLogger(__name__)
+
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            for attempt in range(retry_times):
+                try:
+                    return await func(*args, **kwargs)
+                except exceptions as e:
+                    if attempt == retry_times - 1:
+                        raise
+                    logger.warning(f"Attempt {attempt + 1} failed: {str(e)}")
+                    await asyncio.sleep(retry_delay)
+            return await func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

flexllm-0.3.3.dist-info/METADATA

@@ -0,0 +1,573 @@
+Metadata-Version: 2.4
+Name: flexllm
+Version: 0.3.3
+Summary: High-performance LLM client with batch processing, caching, and checkpoint recovery
+Project-URL: Homepage, https://github.com/KenyonY/flexllm
+Project-URL: Repository, https://github.com/KenyonY/flexllm
+Project-URL: Documentation, https://github.com/KenyonY/flexllm#readme
+Project-URL: Issues, https://github.com/KenyonY/flexllm/issues
+Author-email: kunyuan <beidongjiedeguang@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: anthropic,async,batch,cache,claude,gemini,llm,multimodal,openai
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: aiolimiter>=1.1.0
+Requires-Dist: json5>=0.9.0
+Requires-Dist: loguru>=0.6.0
+Requires-Dist: numpy
+Requires-Dist: orjson
+Requires-Dist: pillow
+Requires-Dist: requests>=2.28.0
+Requires-Dist: rich>=12.0.0
+Requires-Dist: tqdm>=4.60.0
+Provides-Extra: all
+Requires-Dist: flaxkv2>=0.1.5; extra == 'all'
+Requires-Dist: google-auth>=2.0.0; extra == 'all'
+Requires-Dist: opencv-python; extra == 'all'
+Requires-Dist: pyyaml>=6.0; extra == 'all'
+Requires-Dist: tiktoken>=0.5.0; extra == 'all'
+Requires-Dist: typer>=0.9.0; extra == 'all'
+Provides-Extra: cache
+Requires-Dist: flaxkv2>=0.1.5; extra == 'cache'
+Provides-Extra: cli
+Requires-Dist: pyyaml>=6.0; extra == 'cli'
+Requires-Dist: typer>=0.9.0; extra == 'cli'
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: isort>=5.12.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.20.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Provides-Extra: image
+Requires-Dist: opencv-python; extra == 'image'
+Provides-Extra: test
+Requires-Dist: flaxkv2>=0.1.5; extra == 'test'
+Requires-Dist: opencv-python; extra == 'test'
+Requires-Dist: pandas>=1.3.0; extra == 'test'
+Requires-Dist: pytest-asyncio>=0.20.0; extra == 'test'
+Requires-Dist: pytest>=7.0.0; extra == 'test'
+Provides-Extra: token
+Requires-Dist: tiktoken>=0.5.0; extra == 'token'
+Provides-Extra: vertex
+Requires-Dist: google-auth>=2.0.0; extra == 'vertex'
+Description-Content-Type: text/markdown
+
+<h1 align="center">flexllm</h1>
+
+<p align="center">
+    <strong>Production-grade LLM client with checkpoint recovery, response caching, and multi-provider support</strong>
+</p>
+
+<p align="center">
+    <a href="https://pypi.org/project/flexllm/">
+        <img src="https://img.shields.io/pypi/v/flexllm?color=brightgreen&style=flat-square" alt="PyPI version">
+    </a>
+    <a href="https://github.com/KenyonY/flexllm/blob/main/LICENSE">
+        <img alt="License" src="https://img.shields.io/github/license/KenyonY/flexllm.svg?color=blue&style=flat-square">
+    </a>
+    <a href="https://pypistats.org/packages/flexllm">
+        <img alt="pypi downloads" src="https://img.shields.io/pypi/dm/flexllm?style=flat-square">
+    </a>
+</p>
+
+---
+
+## Features
+
+| Feature | Description |
+|---------|-------------|
+| **Checkpoint Recovery** | Batch jobs auto-resume from interruption - process millions of requests without losing progress |
+| **Response Caching** | Built-in intelligent caching with TTL and IPC multi-process sharing - avoid duplicate API calls |
+| **Multi-Provider** | One interface for OpenAI, Gemini, Claude, and any OpenAI-compatible API (vLLM, Ollama, etc.) |
+| **High-Performance Async** | Fine-grained concurrency control, QPS limiting, and streaming batch results |
+| **Load Balancing** | Multi-endpoint distribution with automatic failover (round_robin/weighted/random/fallback) |
+
+---
+
+## Core Strengths
+
+### 1. Checkpoint Recovery - Never Lose Progress
+
+Process millions of requests without fear of interruption. When your batch job crashes at 3 AM, just restart it - flexllm picks up exactly where it left off.
+
+```python
+# Process 100,000 requests - if interrupted, resume automatically
+results = await client.chat_completions_batch(
+    messages_list,
+    output_jsonl="results.jsonl",  # Progress saved here
+)
+# Ctrl+C at 50,000? No problem. Re-run and it continues from 50,001.
+```
+
+### 2. Response Caching - Save Money, Save Time
+
+Built-in intelligent caching avoids duplicate API calls. Same question? Instant answer from cache.
+
+```python
+client = LLMClient(
+    model="gpt-4",
+    cache=ResponseCacheConfig.with_ttl(3600),  # 1 hour cache
+)
+
+# First call: API request (~2s, ~$0.01)
+result1 = await client.chat_completions(messages)
+
+# Second call: Cache hit (~0.001s, $0)
+result2 = await client.chat_completions(messages)
+```
+
+Supports multi-process cache sharing via IPC - perfect for distributed workloads.
+
+### 3. One Interface, All Providers
+
+Write once, run everywhere. Switch between OpenAI, Gemini, Claude, or self-hosted models without changing your code.
+
+```python
+# OpenAI
+client = LLMClient(provider="openai", base_url="https://api.openai.com/v1", ...)
+
+# Gemini
+client = LLMClient(provider="gemini", api_key="...", model="gemini-2.0-flash")
+
+# Claude
+client = LLMClient(provider="claude", api_key="...", model="claude-sonnet-4-20250514")
+
+# Self-hosted (vLLM, Ollama, etc.)
+client = LLMClient(base_url="http://localhost:8000/v1", model="qwen2.5")
+
+# Same API for all:
+result = await client.chat_completions(messages)
+```
+
+### 4. High-Performance Async Engine
+
+Maximize throughput with fine-grained concurrency control and QPS limiting.
+
+```python
+client = LLMClient(
+    concurrency_limit=100,  # 100 concurrent requests
+    max_qps=50,             # Rate limit: 50 req/sec
+    retry_times=3,          # Auto-retry on failure
+)
+
+# Process 10,000 requests with optimal parallelism
+results = await client.chat_completions_batch(messages_list, show_progress=True)
+```
+
+Streaming results - process results as they complete, don't wait for all:
+
+```python
+async for result in client.iter_chat_completions_batch(messages_list):
+    process(result)  # Handle each result immediately
+```
+
+### 5. Load Balancing & Failover
+
+Distribute workloads across multiple endpoints with automatic failover.
+
+```python
+pool = LLMClientPool(
+    endpoints=[
+        {"base_url": "http://gpu1:8000/v1", "model": "qwen"},
+        {"base_url": "http://gpu2:8000/v1", "model": "qwen"},
+        {"base_url": "http://gpu3:8000/v1", "model": "qwen"},
+    ],
+    load_balance="round_robin",  # or "weighted", "random", "fallback"
+    fallback=True,               # Auto-switch on failure
+)
+
+# Requests automatically distributed across healthy endpoints
+results = await pool.chat_completions_batch(messages_list, distribute=True)
+```
+
+### 6. Thinking Mode Support
+
+Unified interface for reasoning models - DeepSeek-R1, Qwen3, Claude extended thinking, Gemini thinking.
+
+```python
+result = await client.chat_completions(
+    messages,
+    thinking=True,      # Enable thinking
+    return_raw=True,
+)
+
+# Unified parsing across all providers
+parsed = client.parse_thoughts(result.data)
+print("Thinking:", parsed["thought"])
+print("Answer:", parsed["answer"])
+```
+
+---
+
+## Installation
+
+```bash
+pip install flexllm
+
+# With caching support
+pip install flexllm[cache]
+
+# With CLI
+pip install flexllm[cli]
+
+# All features
+pip install flexllm[all]
+```
+
+## Quick Start
+
+### Single Request
+
+```python
+from flexllm import LLMClient
+
+client = LLMClient(
+    model="gpt-4",
+    base_url="https://api.openai.com/v1",
+    api_key="your-api-key"
+)
+
+# Async
+response = await client.chat_completions([
+    {"role": "user", "content": "Hello!"}
+])
+
+# Sync
+response = client.chat_completions_sync([
+    {"role": "user", "content": "Hello!"}
+])
+```
+
+### Batch Processing with Checkpoint Recovery
+
+```python
+from flexllm import LLMClient
+
+client = LLMClient(
+    model="gpt-4",
+    base_url="https://api.openai.com/v1",
+    api_key="your-api-key",
+    concurrency_limit=50,
+    max_qps=100,
+)
+
+messages_list = [
+    [{"role": "user", "content": f"Question {i}"}]
+    for i in range(10000)
+]
+
+# If interrupted, re-running resumes from where it stopped
+results = await client.chat_completions_batch(
+    messages_list,
+    output_jsonl="results.jsonl",
+    show_progress=True,
+)
+```
+
+### Response Caching
+
+```python
+from flexllm import LLMClient, ResponseCacheConfig
+
+client = LLMClient(
+    model="gpt-4",
+    base_url="https://api.openai.com/v1",
+    api_key="your-api-key",
+    cache=ResponseCacheConfig.with_ttl(3600),  # 1 hour TTL
+)
+
+# Duplicate requests hit cache automatically
+result1 = await client.chat_completions(messages)  # API call
+result2 = await client.chat_completions(messages)  # Cache hit (instant)
+
+# Multi-process cache sharing (IPC mode - default)
+cache = ResponseCacheConfig.ipc(ttl=86400)  # 24h, shared across processes
+```
+
+### Streaming Response
+
+```python
+async for chunk in client.chat_completions_stream(messages):
+    print(chunk, end="", flush=True)
+```
+
+### Multi-Modal (Vision)
+
+```python
+from flexllm import MllmClient
+
+client = MllmClient(
+    base_url="https://api.openai.com/v1",
+    api_key="your-api-key",
+    model="gpt-4o",
+)
+
+messages = [
+    {
+        "role": "user",
+        "content": [
+            {"type": "text", "text": "What's in this image?"},
+            {"type": "image_url", "image_url": {"url": "path/to/image.jpg"}}
+        ]
+    }
+]
+
+response = await client.call_llm([messages])
+```
+
+### Load Balancing with Failover
+
+```python
+from flexllm import LLMClientPool
+
+pool = LLMClientPool(
+    endpoints=[
+        {"base_url": "http://host1:8000/v1", "api_key": "key1", "model": "qwen"},
+        {"base_url": "http://host2:8000/v1", "api_key": "key2", "model": "qwen"},
+    ],
+    load_balance="round_robin",
+    fallback=True,
+)
+
+# Single request with automatic failover
+result = await pool.chat_completions(messages)
+
+# Batch requests distributed across endpoints
+results = await pool.chat_completions_batch(messages_list, distribute=True)
+```
+
+### Gemini Client
+
+```python
+from flexllm import GeminiClient
+
+# Gemini Developer API
+client = GeminiClient(
+    model="gemini-2.0-flash",
+    api_key="your-gemini-api-key"
+)
+
+# With thinking mode
+response = await client.chat_completions(
+    messages,
+    thinking="high",  # False, True, "minimal", "low", "medium", "high"
+)
+
+# Vertex AI mode
+client = GeminiClient(
+    model="gemini-2.0-flash",
+    project_id="your-project-id",
+    location="us-central1",
+    use_vertex_ai=True,
+)
+```
+
+### Claude Client
+
+```python
+from flexllm import LLMClient, ClaudeClient
+
+# Using unified LLMClient (recommended)
+client = LLMClient(
+    provider="claude",
+    api_key="your-anthropic-key",
+    model="claude-sonnet-4-20250514",
+)
+
+response = await client.chat_completions([
+    {"role": "user", "content": "Hello, Claude!"}
+])
+
+# With extended thinking
+result = await client.chat_completions(
+    messages,
+    thinking=True,
+    return_raw=True,
+)
+parsed = client.parse_thoughts(result.data)
+```
+
+### Function Calling (Tool Use)
+
+```python
+from flexllm import LLMClient
+
+client = LLMClient(
+    base_url="https://api.openai.com/v1",
+    api_key="your-api-key",
+    model="gpt-4",
+)
+
+tools = [
+    {
+        "type": "function",
+        "function": {
+            "name": "get_weather",
+            "description": "Get current weather for a location",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "location": {"type": "string", "description": "City name"}
+                },
+                "required": ["location"]
+            }
+        }
+    }
+]
+
+result = await client.chat_completions(
+    messages=[{"role": "user", "content": "What's the weather in Tokyo?"}],
+    tools=tools,
+    return_usage=True,
+)
+
+if result.tool_calls:
+    for tool_call in result.tool_calls:
+        print(f"Function: {tool_call.function['name']}")
+        print(f"Arguments: {tool_call.function['arguments']}")
+```
+
+## CLI Usage
+
+```bash
+# Quick ask
+flexllm ask "What is Python?"
+flexllm ask "Explain this" -s "You are a code expert"
+echo "long text" | flexllm ask "Summarize"
+
+# Interactive chat
+flexllm chat
+flexllm chat --model=gpt-4 "Hello"
+
+# Batch processing with checkpoint recovery
+flexllm batch input.jsonl -o output.jsonl
+
+# List models
+flexllm models           # Remote models
+flexllm list_models      # Configured models
+
+# Test connection
+flexllm test
+
+# Initialize config
+flexllm init
+```
+
+### CLI Configuration
+
+Create `~/.flexllm/config.yaml`:
+
+```yaml
+default: "gpt-4"
+
+models:
+  - id: gpt-4
+    name: gpt-4
+    provider: openai
+    base_url: https://api.openai.com/v1
+    api_key: your-api-key
+
+  - id: local
+    name: local-ollama
+    provider: openai
+    base_url: http://localhost:11434/v1
+    api_key: EMPTY
+```
+
+Or use environment variables:
+
+```bash
+export FLEXLLM_BASE_URL="https://api.openai.com/v1"
+export FLEXLLM_API_KEY="your-key"
+export FLEXLLM_MODEL="gpt-4"
+```
+
+## API Reference
+
+### LLMClient
+
+```python
+LLMClient(
+    provider: str = "auto",        # "auto", "openai", "gemini", "claude"
+    model: str,                    # Model name
+    base_url: str,                 # API base URL
+    api_key: str = "EMPTY",        # API key
+    cache: ResponseCacheConfig,    # Cache config
+    concurrency_limit: int = 10,   # Max concurrent requests
+    max_qps: float = None,         # Max requests per second
+    retry_times: int = 3,          # Retry count on failure
+    retry_delay: float = 1.0,      # Delay between retries
+    timeout: int = 120,            # Request timeout (seconds)
+)
+```
+
+### Methods
+
+| Method | Description |
+|--------|-------------|
+| `chat_completions(messages)` | Single async request |
+| `chat_completions_sync(messages)` | Single sync request |
+| `chat_completions_batch(messages_list)` | Batch async with checkpoint |
+| `chat_completions_batch_sync(messages_list)` | Batch sync with checkpoint |
+| `iter_chat_completions_batch(messages_list)` | Streaming batch results |
+| `chat_completions_stream(messages)` | Token-by-token streaming |
+| `parse_thoughts(response_data)` | Parse thinking content |
+
+### ResponseCacheConfig
+
+```python
+# Shortcuts
+ResponseCacheConfig.with_ttl(3600)     # 1 hour TTL
+ResponseCacheConfig.persistent()        # Never expire
+ResponseCacheConfig.ipc(ttl=86400)      # Multi-process shared (default)
+ResponseCacheConfig.local(ttl=86400)    # Single process only
+
+# Full config
+ResponseCacheConfig(
+    enabled: bool = False,
+    ttl: int = 86400,              # Time-to-live in seconds
+    cache_dir: str = "~/.cache/flexllm/llm_response",
+    use_ipc: bool = True,          # Multi-process cache sharing
+)
+```
+
+### Token Counting
+
+```python
+from flexllm import count_tokens, estimate_cost, estimate_batch_cost
+
+tokens = count_tokens("Hello world", model="gpt-4")
+cost = estimate_cost(tokens, model="gpt-4", is_input=True)
+total_cost = estimate_batch_cost(messages_list, model="gpt-4")
+```
+
+## Architecture
+
+```
+LLMClient (Unified entry point)
+    ├── OpenAIClient (OpenAI-compatible APIs)
+    ├── GeminiClient (Google Gemini)
+    └── ClaudeClient (Anthropic Claude)
+            │
+            └── LLMClientBase (Abstract base - 4 methods to implement)
+                    │
+                    ├── ConcurrentRequester (Async engine with QPS control)
+                    ├── ResponseCache (FlaxKV2-based caching with IPC)
+                    └── ImageProcessor (Multi-modal support)
+
+LLMClientPool (Multi-endpoint load balancing)
+    └── ProviderRouter (round_robin / weighted / random / fallback)
+```
+
+## License
+
+Apache 2.0

flexllm-0.3.3.dist-info/RECORD

@@ -0,0 +1,39 @@
+flexllm/__init__.py,sha256=GMd4DJMgpxUGaLZ55X5pdSJoa-79lZCIBtyPr63IHH4,7160
+flexllm/__main__.py,sha256=n63FUI84kJ81A1PQW0Takd9s4yVExGCzyGDDw0gTMzY,40789
+flexllm/base_client.py,sha256=_82yHc7QieIr0OMFU5hqjrshnLq1ROIyzdjVdFUTJTs,42204
+flexllm/chain_of_thought_client.py,sha256=ohmUaEWtvfIFFrw_h2ADNSkiEVE_qryLr18KtWzU00Y,41351
+flexllm/claudeclient.py,sha256=BTmkh5bc0Lgvo90v-XB_bc_vFPaaUhc8hol2nXc12ec,15060
+flexllm/client_pool.py,sha256=yZlCO7aopAgKhpHn5tG6OwCzLzMcAFt4ovH1MEJ8-AY,24229
+flexllm/geminiclient.py,sha256=2K03uGIpED7ryul7dmftpIq5OuY_ZIIVYHbnIUADu9s,20306
+flexllm/llm_client.py,sha256=U0zoMsf1q7VX0CYlB6MGgjqynlTCs8QtqTkIzzStkV4,19002
+flexllm/llm_parser.py,sha256=raQnxIuSUNbRvrBLeZnpIIkDCcO2UzThtplGy8Cb1Y8,1832
+flexllm/mllm_client.py,sha256=a6C2JJPrA6JW3XN07ZPQ0xVqc2ketMEQWKCK0uupEvw,17251
+flexllm/openaiclient.py,sha256=pb8ttzPYMC7pLVMCpRXknzs2-kC-CmM73nUHw5bo7gw,8377
+flexllm/provider_router.py,sha256=PElAQ4v6Go21VxTm9LF5_w0Pkt6GcOYJDp-OKRIEFtU,5978
+flexllm/token_counter.py,sha256=GHzZwniQo4uaDfXRgljzVvoTfcKzkZTpP4S3VJ2PGXE,8188
+flexllm/async_api/__init__.py,sha256=LqybQzdw2JfpdOMMeif9qlTIm68oOg3UseFBC17lcDg,196
+flexllm/async_api/concurrent_call.py,sha256=pymX43aQ4HdiGUk5oPheOsWssjnitDz0nLbQ0N7B5tQ,2904
+flexllm/async_api/concurrent_executor.py,sha256=-BzI2QH_RkzrCO1_RY0EkOWyAS24HOWncED43SchTq0,33809
+flexllm/async_api/core.py,sha256=UqFQ5A-ObJhmRUS8nheB6UNFCCdfhJk5TkRK3goZSzU,13350
+flexllm/async_api/interface.py,sha256=s6pDxAjm0r0rfXWYvEnY9qmGl571thm7cKHqPlyxfGU,227
+flexllm/async_api/progress.py,sha256=n8Mlf6rpNotEdZ6n6snkUN9JhSorcGCUR8ZGkue9yTs,10537
+flexllm/batch_tools/__init__.py,sha256=2hK377iLyFxv5HXc2CK4b6ff_gC5eUKlyv11vhXEhaU,392
+flexllm/batch_tools/folder_processor.py,sha256=FjkeGqowRxtvvCYpGYHWGx7esdJ5OOpPMo3cQ9oR2QE,10695
+flexllm/batch_tools/table_processor.py,sha256=VRH5kZK3QPcVrc_ZSQSszMPYlw0lzMLk3Yata6Ub9FE,11490
+flexllm/cache/__init__.py,sha256=yVRpoQNltmcupnOt5daiFrJ5zv7SV71oOsBkbK390tA,241
+flexllm/cache/response_cache.py,sha256=lkOKESR3aAXkAde6s0zL5KsH2l8vmDI6QMiDKyTKv_U,8300
+flexllm/msg_processors/__init__.py,sha256=je_TqbV_QeSFHJV-zUq9hhyml7rsnKMZw8gYwzDCqzs,5799
+flexllm/msg_processors/image_processor.py,sha256=gg2eJYav1_AhzB1JYCBDP8wxfNHEarKAyhINZsnXC9o,28915
+flexllm/msg_processors/image_processor_helper.py,sha256=QIc_MkD2EYPmc1SyfBDani9yfiQ62FhrWCzn-0k9wRI,16067
+flexllm/msg_processors/messages_processor.py,sha256=Rzn1lt361gwNctyAhUmiEkZgTogsGXEYE1LSApqGJe4,13199
+flexllm/msg_processors/unified_processor.py,sha256=IKRO1rR0gJxir_nPnahVYboqufRPsnSjvtnjkSwLjhc,49103
+flexllm/pricing/__init__.py,sha256=4HjLPiBy5WHDaQ0Idp-sVPUt5W_UxZeeq38nJwIKga0,2586
+flexllm/pricing/data.json,sha256=QKEmoa6WjC3CpH8nWwxYL0cy5VXS15LI8UDNe2QwqXI,22334
+flexllm/pricing/updater.py,sha256=TvKOtBLgc8VWwBY4pwOQlTDZmJ2kEZe1GYxYh_GE8Rs,5837
+flexllm/utils/__init__.py,sha256=-BAWBrc4Kc18yrPK_OTOa4JaDyx2OgFcRuIiQe-zYeI,30
+flexllm/utils/core.py,sha256=eraE-FMnQ4vYmdjgs82ZdakcHTEn9dXbTHFZ76plnWw,1079
+flexllm-0.3.3.dist-info/METADATA,sha256=blNSncn_AILRQwXgTrmAw46NIiv-IDjFfvhf6-DahpM,15697
+flexllm-0.3.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+flexllm-0.3.3.dist-info/entry_points.txt,sha256=BWKjRwFpLLBW8GLo6M-B15VYWiefec4kuFFdVtyOSLY,79
+flexllm-0.3.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+flexllm-0.3.3.dist-info/RECORD,,

flexllm-0.3.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

flexllm-0.3.3.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+flexllm = flexllm.__main__:main
+xllm = flexllm.__main__:main