prompture 0.0.32.dev1__py3-none-any.whl → 0.0.33__py3-none-any.whl

prompture/__init__.py

@@ -13,7 +13,7 @@ from .core import (
     extract_from_pandas,
     render_output,
 )
-from .drivers import get_driver, get_driver_for_model, OpenAIDriver, LocalHTTPDriver, OllamaDriver, ClaudeDriver, LMStudioDriver, AzureDriver, GoogleDriver, GroqDriver, OpenRouterDriver, GrokDriver
+from .drivers import get_driver, get_driver_for_model, OpenAIDriver, LocalHTTPDriver, OllamaDriver, ClaudeDriver, LMStudioDriver, AzureDriver, GoogleDriver, GroqDriver, OpenRouterDriver, GrokDriver, AirLLMDriver
 from .tools import clean_json_text, clean_toon_text
 from .field_definitions import (
     FIELD_DEFINITIONS, get_field_definition, get_required_fields, get_field_names,
@@ -24,6 +24,7 @@ from .field_definitions import (
 from .runner import run_suite_from_spec
 from .validator import validate_against_schema
 from .discovery import get_available_models
+from .model_rates import get_model_rates, get_model_info, refresh_rates_cache
 
 # Load environment variables from .env file
 load_dotenv()
@@ -87,6 +88,11 @@ __all__ = [
     "GroqDriver",
     "OpenRouterDriver",
     "GrokDriver",
+    "AirLLMDriver",
     # Discovery
     "get_available_models",
+    # Model Rates
+    "get_model_rates",
+    "get_model_info",
+    "refresh_rates_cache",
 ]

prompture/discovery.py

@@ -33,7 +33,8 @@ def get_available_models() -> List[str]:
         A list of unique model strings in the format "provider/model_id".
     """
     available_models: Set[str] = set()
-    
+    configured_providers: Set[str] = set()
+
     # Map of provider name to driver class
     # We need to map the registry keys to the actual classes to check MODEL_PRICING
     # and instantiate for dynamic checks if needed.
@@ -96,6 +97,8 @@ def get_available_models() -> List[str]:
             if not is_configured:
                 continue
 
+            configured_providers.add(provider)
+
             # 2. Static Detection: Get models from MODEL_PRICING
             if hasattr(driver_cls, "MODEL_PRICING"):
                 pricing = driver_cls.MODEL_PRICING
@@ -146,4 +149,11 @@ def get_available_models() -> List[str]:
             logger.warning(f"Error detecting models for provider {provider}: {e}")
             continue
 
+    # Enrich with live model list from models.dev cache
+    from .model_rates import get_all_provider_models, PROVIDER_MAP
+    for prompture_name, api_name in PROVIDER_MAP.items():
+        if prompture_name in configured_providers:
+            for model_id in get_all_provider_models(api_name):
+                available_models.add(f"{prompture_name}/{model_id}")
+
     return sorted(list(available_models))

prompture/drivers/__init__.py

@@ -8,6 +8,7 @@ from .google_driver import GoogleDriver
 from .groq_driver import GroqDriver
 from .openrouter_driver import OpenRouterDriver
 from .grok_driver import GrokDriver
+from .airllm_driver import AirLLMDriver
 from ..settings import settings
 
 
@@ -54,6 +55,10 @@ DRIVER_REGISTRY = {
         api_key=settings.grok_api_key,
         model=model or settings.grok_model
     ),
+    "airllm": lambda model=None: AirLLMDriver(
+        model=model or settings.airllm_model,
+        compression=settings.airllm_compression,
+    ),
 }
 
 
@@ -115,6 +120,7 @@ __all__ = [
     "GroqDriver",
     "OpenRouterDriver",
     "GrokDriver",
+    "AirLLMDriver",
     "get_driver",
     "get_driver_for_model",
 ]

prompture/drivers/airllm_driver.py

@@ -0,0 +1,116 @@
+import logging
+from ..driver import Driver
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class AirLLMDriver(Driver):
+    """Driver for AirLLM — run large models (70B+) on consumer GPUs via
+    layer-by-layer memory management.
+
+    The ``airllm`` package is a lazy dependency: it is imported on first
+    ``generate()`` call so the rest of Prompture works without it installed.
+    """
+
+    MODEL_PRICING = {
+        "default": {"prompt": 0.0, "completion": 0.0}
+    }
+
+    def __init__(self, model: str = "meta-llama/Llama-2-7b-hf",
+                 compression: Optional[str] = None):
+        """
+        Args:
+            model: HuggingFace repo ID (e.g. ``"meta-llama/Llama-2-70b-hf"``).
+            compression: Optional quantization mode — ``"4bit"`` or ``"8bit"``.
+        """
+        self.model = model
+        self.compression = compression
+        self.options: Dict[str, Any] = {}
+        self._llm = None
+        self._tokenizer = None
+
+    # ------------------------------------------------------------------
+    # Lazy model loading
+    # ------------------------------------------------------------------
+    def _ensure_loaded(self):
+        """Load the AirLLM model and tokenizer on first use."""
+        if self._llm is not None:
+            return
+
+        try:
+            from airllm import AutoModel
+        except ImportError:
+            raise ImportError(
+                "The 'airllm' package is required for the AirLLM driver. "
+                "Install it with: pip install prompture[airllm]"
+            )
+
+        try:
+            from transformers import AutoTokenizer
+        except ImportError:
+            raise ImportError(
+                "The 'transformers' package is required for the AirLLM driver. "
+                "Install it with: pip install transformers"
+            )
+
+        logger.info(f"Loading AirLLM model: {self.model} "
+                     f"(compression={self.compression})")
+
+        load_kwargs: Dict[str, Any] = {}
+        if self.compression:
+            load_kwargs["compression"] = self.compression
+
+        self._llm = AutoModel.from_pretrained(self.model, **load_kwargs)
+        self._tokenizer = AutoTokenizer.from_pretrained(self.model)
+        logger.info("AirLLM model loaded successfully")
+
+    # ------------------------------------------------------------------
+    # Driver interface
+    # ------------------------------------------------------------------
+    def generate(self, prompt: str, options: Dict[str, Any] = None) -> Dict[str, Any]:
+        self._ensure_loaded()
+
+        merged_options = self.options.copy()
+        if options:
+            merged_options.update(options)
+
+        max_new_tokens = merged_options.get("max_new_tokens", 256)
+
+        # Tokenize
+        input_ids = self._tokenizer(
+            prompt, return_tensors="pt"
+        ).input_ids
+
+        prompt_tokens = input_ids.shape[1]
+
+        logger.debug(f"AirLLM generating with max_new_tokens={max_new_tokens}, "
+                      f"prompt_tokens={prompt_tokens}")
+
+        # Generate
+        output_ids = self._llm.generate(
+            input_ids,
+            max_new_tokens=max_new_tokens,
+        )
+
+        # Decode only the newly generated tokens (strip the prompt prefix)
+        new_tokens = output_ids[0, prompt_tokens:]
+        completion_tokens = len(new_tokens)
+        text = self._tokenizer.decode(new_tokens, skip_special_tokens=True)
+
+        total_tokens = prompt_tokens + completion_tokens
+
+        meta = {
+            "prompt_tokens": prompt_tokens,
+            "completion_tokens": completion_tokens,
+            "total_tokens": total_tokens,
+            "cost": 0.0,
+            "raw_response": {
+                "model": self.model,
+                "compression": self.compression,
+                "max_new_tokens": max_new_tokens,
+            },
+            "model_name": self.model,
+        }
+
+        return {"text": text, "meta": meta}

prompture/drivers/azure_driver.py

@@ -111,10 +111,16 @@ class AzureDriver(Driver):
         completion_tokens = getattr(usage, "completion_tokens", 0)
         total_tokens = getattr(usage, "total_tokens", 0)
 
-        # Calculate cost
-        model_pricing = self.MODEL_PRICING.get(model, {"prompt": 0, "completion": 0})
-        prompt_cost = (prompt_tokens / 1000) * model_pricing["prompt"]
-        completion_cost = (completion_tokens / 1000) * model_pricing["completion"]
+        # Calculate cost — try live rates first (per 1M tokens), fall back to hardcoded (per 1K tokens)
+        from ..model_rates import get_model_rates
+        live_rates = get_model_rates("azure", model)
+        if live_rates:
+            prompt_cost = (prompt_tokens / 1_000_000) * live_rates["input"]
+            completion_cost = (completion_tokens / 1_000_000) * live_rates["output"]
+        else:
+            model_pricing = self.MODEL_PRICING.get(model, {"prompt": 0, "completion": 0})
+            prompt_cost = (prompt_tokens / 1000) * model_pricing["prompt"]
+            completion_cost = (completion_tokens / 1000) * model_pricing["completion"]
         total_cost = prompt_cost + completion_cost
 
         # Standardized meta object

prompture/drivers/claude_driver.py

@@ -64,10 +64,16 @@ class ClaudeDriver(Driver):
         completion_tokens = resp.usage.output_tokens
         total_tokens = prompt_tokens + completion_tokens
         
-        # Calculate cost based on model pricing
-        model_pricing = self.MODEL_PRICING.get(model, {"prompt": 0, "completion": 0})
-        prompt_cost = (prompt_tokens / 1000) * model_pricing["prompt"]
-        completion_cost = (completion_tokens / 1000) * model_pricing["completion"]
+        # Calculate cost — try live rates first (per 1M tokens), fall back to hardcoded (per 1K tokens)
+        from ..model_rates import get_model_rates
+        live_rates = get_model_rates("claude", model)
+        if live_rates:
+            prompt_cost = (prompt_tokens / 1_000_000) * live_rates["input"]
+            completion_cost = (completion_tokens / 1_000_000) * live_rates["output"]
+        else:
+            model_pricing = self.MODEL_PRICING.get(model, {"prompt": 0, "completion": 0})
+            prompt_cost = (prompt_tokens / 1000) * model_pricing["prompt"]
+            completion_cost = (completion_tokens / 1000) * model_pricing["completion"]
         total_cost = prompt_cost + completion_cost
         
         # Create standardized meta object

prompture/drivers/google_driver.py

@@ -134,14 +134,22 @@ class GoogleDriver(Driver):
                 raise ValueError("Empty response from model")
 
             # Calculate token usage and cost
-            # Note: Using character count as proxy since Google charges per character
             prompt_chars = len(prompt)
             completion_chars = len(response.text)
-            
-            # Calculate costs
-            model_pricing = self.MODEL_PRICING.get(self.model, {"prompt": 0, "completion": 0})
-            prompt_cost = (prompt_chars / 1_000_000) * model_pricing["prompt"]
-            completion_cost = (completion_chars / 1_000_000) * model_pricing["completion"]
+
+            # Try live rates first (per 1M tokens), fall back to hardcoded character-based pricing
+            from ..model_rates import get_model_rates
+            live_rates = get_model_rates("google", self.model)
+            if live_rates:
+                # models.dev reports token-based pricing; estimate tokens from chars (~4 chars/token)
+                est_prompt_tokens = prompt_chars / 4
+                est_completion_tokens = completion_chars / 4
+                prompt_cost = (est_prompt_tokens / 1_000_000) * live_rates["input"]
+                completion_cost = (est_completion_tokens / 1_000_000) * live_rates["output"]
+            else:
+                model_pricing = self.MODEL_PRICING.get(self.model, {"prompt": 0, "completion": 0})
+                prompt_cost = (prompt_chars / 1_000_000) * model_pricing["prompt"]
+                completion_cost = (completion_chars / 1_000_000) * model_pricing["completion"]
             total_cost = prompt_cost + completion_cost
 
             meta = {

prompture/drivers/grok_driver.py

@@ -133,10 +133,16 @@ class GrokDriver(Driver):
         completion_tokens = usage.get("completion_tokens", 0) 
         total_tokens = usage.get("total_tokens", 0)
 
-        # Calculate cost
-        model_pricing = self.MODEL_PRICING.get(model, {"prompt": 0, "completion": 0})
-        prompt_cost = (prompt_tokens / 1000000) * model_pricing["prompt"]
-        completion_cost = (completion_tokens / 1000000) * model_pricing["completion"]
+        # Calculate cost — try live rates first (per 1M tokens), fall back to hardcoded (per 1M tokens)
+        from ..model_rates import get_model_rates
+        live_rates = get_model_rates("grok", model)
+        if live_rates:
+            prompt_cost = (prompt_tokens / 1_000_000) * live_rates["input"]
+            completion_cost = (completion_tokens / 1_000_000) * live_rates["output"]
+        else:
+            model_pricing = self.MODEL_PRICING.get(model, {"prompt": 0, "completion": 0})
+            prompt_cost = (prompt_tokens / 1_000_000) * model_pricing["prompt"]
+            completion_cost = (completion_tokens / 1_000_000) * model_pricing["completion"]
         total_cost = prompt_cost + completion_cost
 
         # Standardized meta object

prompture/drivers/groq_driver.py

@@ -96,10 +96,16 @@ class GroqDriver(Driver):
         completion_tokens = getattr(usage, "completion_tokens", 0) 
         total_tokens = getattr(usage, "total_tokens", 0)
 
-        # Calculate costs
-        model_pricing = self.MODEL_PRICING.get(model, {"prompt": 0, "completion": 0})
-        prompt_cost = (prompt_tokens / 1000) * model_pricing["prompt"]
-        completion_cost = (completion_tokens / 1000) * model_pricing["completion"]
+        # Calculate costs — try live rates first (per 1M tokens), fall back to hardcoded (per 1K tokens)
+        from ..model_rates import get_model_rates
+        live_rates = get_model_rates("groq", model)
+        if live_rates:
+            prompt_cost = (prompt_tokens / 1_000_000) * live_rates["input"]
+            completion_cost = (completion_tokens / 1_000_000) * live_rates["output"]
+        else:
+            model_pricing = self.MODEL_PRICING.get(model, {"prompt": 0, "completion": 0})
+            prompt_cost = (prompt_tokens / 1000) * model_pricing["prompt"]
+            completion_cost = (completion_tokens / 1000) * model_pricing["completion"]
         total_cost = prompt_cost + completion_cost
 
         # Standard metadata object

prompture/drivers/openai_driver.py

@@ -97,10 +97,16 @@ class OpenAIDriver(Driver):
         completion_tokens = getattr(usage, "completion_tokens", 0)
         total_tokens = getattr(usage, "total_tokens", 0)
 
-        # Calculate cost
-        model_pricing = self.MODEL_PRICING.get(model, {"prompt": 0, "completion": 0})
-        prompt_cost = (prompt_tokens / 1000) * model_pricing["prompt"]
-        completion_cost = (completion_tokens / 1000) * model_pricing["completion"]
+        # Calculate cost — try live rates first (per 1M tokens), fall back to hardcoded (per 1K tokens)
+        from ..model_rates import get_model_rates
+        live_rates = get_model_rates("openai", model)
+        if live_rates:
+            prompt_cost = (prompt_tokens / 1_000_000) * live_rates["input"]
+            completion_cost = (completion_tokens / 1_000_000) * live_rates["output"]
+        else:
+            model_pricing = self.MODEL_PRICING.get(model, {"prompt": 0, "completion": 0})
+            prompt_cost = (prompt_tokens / 1000) * model_pricing["prompt"]
+            completion_cost = (completion_tokens / 1000) * model_pricing["completion"]
         total_cost = prompt_cost + completion_cost
 
         # Standardized meta object

prompture/drivers/openrouter_driver.py

@@ -110,10 +110,16 @@ class OpenRouterDriver(Driver):
             completion_tokens = usage.get("completion_tokens", 0)
             total_tokens = usage.get("total_tokens", 0)
 
-            # Calculate cost
-            model_pricing = self.MODEL_PRICING.get(model, {"prompt": 0, "completion": 0})
-            prompt_cost = (prompt_tokens / 1000) * model_pricing["prompt"]
-            completion_cost = (completion_tokens / 1000) * model_pricing["completion"]
+            # Calculate cost — try live rates first (per 1M tokens), fall back to hardcoded (per 1K tokens)
+            from ..model_rates import get_model_rates
+            live_rates = get_model_rates("openrouter", model)
+            if live_rates:
+                prompt_cost = (prompt_tokens / 1_000_000) * live_rates["input"]
+                completion_cost = (completion_tokens / 1_000_000) * live_rates["output"]
+            else:
+                model_pricing = self.MODEL_PRICING.get(model, {"prompt": 0, "completion": 0})
+                prompt_cost = (prompt_tokens / 1000) * model_pricing["prompt"]
+                completion_cost = (completion_tokens / 1000) * model_pricing["completion"]
             total_cost = prompt_cost + completion_cost
 
             # Standardized meta object

prompture/model_rates.py

@@ -0,0 +1,216 @@
+"""Live model rates from models.dev API with local caching.
+
+Fetches pricing and metadata for LLM models from https://models.dev/api.json,
+caches locally with TTL-based auto-refresh, and provides lookup functions
+used by drivers for cost calculations.
+"""
+
+import json
+import logging
+import threading
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+# Maps prompture provider names to models.dev provider names
+PROVIDER_MAP: Dict[str, str] = {
+    "openai": "openai",
+    "claude": "anthropic",
+    "google": "google",
+    "groq": "groq",
+    "grok": "xai",
+    "azure": "azure",
+    "openrouter": "openrouter",
+}
+
+_API_URL = "https://models.dev/api.json"
+_CACHE_DIR = Path.home() / ".prompture" / "cache"
+_CACHE_FILE = _CACHE_DIR / "models_dev.json"
+_META_FILE = _CACHE_DIR / "models_dev_meta.json"
+
+_lock = threading.Lock()
+_data: Optional[Dict[str, Any]] = None
+_loaded = False
+
+
+def _get_ttl_days() -> int:
+    """Get TTL from settings if available, otherwise default to 7."""
+    try:
+        from .settings import settings
+        return getattr(settings, "model_rates_ttl_days", 7)
+    except Exception:
+        return 7
+
+
+def _cache_is_valid() -> bool:
+    """Check whether the local cache exists and is within TTL."""
+    if not _CACHE_FILE.exists() or not _META_FILE.exists():
+        return False
+    try:
+        meta = json.loads(_META_FILE.read_text(encoding="utf-8"))
+        fetched_at = datetime.fromisoformat(meta["fetched_at"])
+        ttl_days = meta.get("ttl_days", _get_ttl_days())
+        age = datetime.now(timezone.utc) - fetched_at
+        return age.total_seconds() < ttl_days * 86400
+    except Exception:
+        return False
+
+
+def _write_cache(data: Dict[str, Any]) -> None:
+    """Write API data and metadata to local cache."""
+    try:
+        _CACHE_DIR.mkdir(parents=True, exist_ok=True)
+        _CACHE_FILE.write_text(json.dumps(data), encoding="utf-8")
+        meta = {
+            "fetched_at": datetime.now(timezone.utc).isoformat(),
+            "ttl_days": _get_ttl_days(),
+        }
+        _META_FILE.write_text(json.dumps(meta), encoding="utf-8")
+    except Exception as exc:
+        logger.debug("Failed to write model rates cache: %s", exc)
+
+
+def _read_cache() -> Optional[Dict[str, Any]]:
+    """Read cached API data from disk."""
+    try:
+        return json.loads(_CACHE_FILE.read_text(encoding="utf-8"))
+    except Exception:
+        return None
+
+
+def _fetch_from_api() -> Optional[Dict[str, Any]]:
+    """Fetch fresh data from models.dev API."""
+    try:
+        import requests
+        resp = requests.get(_API_URL, timeout=15)
+        resp.raise_for_status()
+        return resp.json()
+    except Exception as exc:
+        logger.debug("Failed to fetch model rates from %s: %s", _API_URL, exc)
+        return None
+
+
+def _ensure_loaded() -> Optional[Dict[str, Any]]:
+    """Lazy-load data: use cache if valid, otherwise fetch from API."""
+    global _data, _loaded
+    if _loaded:
+        return _data
+
+    with _lock:
+        # Double-check after acquiring lock
+        if _loaded:
+            return _data
+
+        if _cache_is_valid():
+            _data = _read_cache()
+            if _data is not None:
+                _loaded = True
+                return _data
+
+        # Cache missing or expired — fetch fresh
+        fresh = _fetch_from_api()
+        if fresh is not None:
+            _data = fresh
+            _write_cache(fresh)
+        else:
+            # Fetch failed — try stale cache as last resort
+            _data = _read_cache()
+
+        _loaded = True
+        return _data
+
+
+def _lookup_model(provider: str, model_id: str) -> Optional[Dict[str, Any]]:
+    """Find a model entry in the cached data.
+
+    The API structure is ``{provider: {model_id: {...}, ...}, ...}``.
+    """
+    data = _ensure_loaded()
+    if data is None:
+        return None
+
+    api_provider = PROVIDER_MAP.get(provider, provider)
+    provider_data = data.get(api_provider)
+    if not isinstance(provider_data, dict):
+        return None
+
+    return provider_data.get(model_id)
+
+
+# ── Public API ──────────────────────────────────────────────────────────────
+
+
+def get_model_rates(provider: str, model_id: str) -> Optional[Dict[str, float]]:
+    """Return pricing dict for a model, or ``None`` if unavailable.
+
+    Returned keys mirror models.dev cost fields (per 1M tokens):
+    ``input``, ``output``, and optionally ``cache_read``, ``cache_write``,
+    ``reasoning``.
+    """
+    entry = _lookup_model(provider, model_id)
+    if entry is None:
+        return None
+
+    cost = entry.get("cost")
+    if not isinstance(cost, dict):
+        return None
+
+    rates: Dict[str, float] = {}
+    for key in ("input", "output", "cache_read", "cache_write", "reasoning"):
+        val = cost.get(key)
+        if val is not None:
+            try:
+                rates[key] = float(val)
+            except (TypeError, ValueError):
+                pass
+
+    # Must have at least input and output to be useful
+    if "input" in rates and "output" in rates:
+        return rates
+    return None
+
+
+def get_model_info(provider: str, model_id: str) -> Optional[Dict[str, Any]]:
+    """Return full model metadata (cost, limits, capabilities), or ``None``."""
+    return _lookup_model(provider, model_id)
+
+
+def get_all_provider_models(provider: str) -> List[str]:
+    """Return list of model IDs available for a provider."""
+    data = _ensure_loaded()
+    if data is None:
+        return []
+
+    api_provider = PROVIDER_MAP.get(provider, provider)
+    provider_data = data.get(api_provider)
+    if not isinstance(provider_data, dict):
+        return []
+
+    return list(provider_data.keys())
+
+
+def refresh_rates_cache(force: bool = False) -> bool:
+    """Fetch fresh data from models.dev.
+
+    Args:
+        force: If ``True``, fetch even when the cache is still within TTL.
+
+    Returns:
+        ``True`` if fresh data was fetched and cached successfully.
+    """
+    global _data, _loaded
+
+    with _lock:
+        if not force and _cache_is_valid():
+            return False
+
+        fresh = _fetch_from_api()
+        if fresh is not None:
+            _data = fresh
+            _write_cache(fresh)
+            _loaded = True
+            return True
+
+        return False

prompture/settings.py

@@ -48,6 +48,13 @@ class Settings(BaseSettings):
     grok_api_key: Optional[str] = None
     grok_model: str = "grok-4-fast-reasoning"
 
+    # AirLLM
+    airllm_model: str = "meta-llama/Llama-2-7b-hf"
+    airllm_compression: Optional[str] = None  # "4bit" or "8bit"
+
+    # Model rates cache
+    model_rates_ttl_days: int = 7  # How often to refresh models.dev cache
+
     model_config = SettingsConfigDict(
         env_file=".env",
         extra="ignore",

{prompture-0.0.32.dev1.dist-info → prompture-0.0.33.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompture
-Version: 0.0.32.dev1
+Version: 0.0.33
 Summary: Ask LLMs to return structured JSON and run cross-model tests. API-first.
 Home-page: https://github.com/jhd3197/prompture
 Author: Juan Denis
@@ -29,6 +29,8 @@ Requires-Dist: tukuy>=0.0.6
 Requires-Dist: pyyaml>=6.0
 Provides-Extra: test
 Requires-Dist: pytest>=7.0; extra == "test"
+Provides-Extra: airllm
+Requires-Dist: airllm>=2.8.0; extra == "airllm"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

prompture-0.0.33.dist-info/RECORD

@@ -0,0 +1,30 @@
+prompture/__init__.py,sha256=gnZYWKiWV_FTUeG9A88nkgPrAwtx6U_23UrOYhNTiOw,2891
+prompture/cli.py,sha256=vA86GNjtKSHz8eRMl5YDaT9HHIWuhkeJtfx8jqTaqtM,809
+prompture/core.py,sha256=x_FhOY37ygQVHo4zHUyiWsV4BuOClkELsVhEV-K4jJ0,53689
+prompture/discovery.py,sha256=JbaOhZuf41yYOFdv6wZmRjfRPum_df5V5fVVbKyOPoY,7240
+prompture/driver.py,sha256=w8pdXHujImIGF3ee8rkG8f6-UD0h2jLHhucSPInRrYI,989
+prompture/field_definitions.py,sha256=6kDMYNedccTK5l2L_I8_NI3_av-iYHqGPwkKDy8214c,21731
+prompture/model_rates.py,sha256=B3VdFFIPaJ31xSIVq96bAD3P4dnrIguauyNrD7WHCgQ,6428
+prompture/runner.py,sha256=5xwal3iBQQj4_q7l3Rjr0e3RrUMJPaPDLiEchO0mmHo,4192
+prompture/settings.py,sha256=F4RQt4HB3rOUMoKs1r-Y7W55Dvk_LdXyTD88S8mMojM,1730
+prompture/tools.py,sha256=qyT8oJl_v9GolABkflW0SvEx22yNkEJZKTu-40nJbs0,40329
+prompture/validator.py,sha256=oLzVsNveHuF-N_uOd11_uDa9Q5rFyo0wrk_l1N4zqDk,996
+prompture/drivers/__init__.py,sha256=hi2u4Z2KQFfgqce1QvjRlDKRzB2xfJZpidGNMsQ82oI,4105
+prompture/drivers/airllm_driver.py,sha256=g1WmQDwSfK0BIyG96JrZY7W_VHXOS7wDSeegE7B1q4Y,3956
+prompture/drivers/azure_driver.py,sha256=t8RsGSexwPaM8VzakMRMpssh7Nf-StY-C5BfWmoXdzE,5016
+prompture/drivers/claude_driver.py,sha256=KcJRIcS9OPK6IBs8pUxxcKFlBH_eivgKLJcDuUk1_YU,3665
+prompture/drivers/google_driver.py,sha256=-fbnJ003VC01YApujNUC1lg7E4J9x-Jm8sEJfLX00cI,6876
+prompture/drivers/grok_driver.py,sha256=24FxmqiZNF8znIATn7CnFExqP_XvivXyvoxVFnC4iW8,5400
+prompture/drivers/groq_driver.py,sha256=FZPz1sPfYj86HjwtHX7U7YE60_oDAfr4TfS1I7NdKzI,4313
+prompture/drivers/hugging_driver.py,sha256=rngz7hIR7l-9M_xe4EjWPaBqdyPFHdQsqnDDy9gm5So,2357
+prompture/drivers/lmstudio_driver.py,sha256=Umy1kT211TAxxSPyQrtZnIGIZgqFeSV87FLTiPFF0CY,3455
+prompture/drivers/local_http_driver.py,sha256=S2diikvtQOQHF7fB07zU2X0QWkej4Of__rJgaU2C6FI,1669
+prompture/drivers/ollama_driver.py,sha256=fq_eFgwmCT3SK1D-ICHjxLjcm_An0suwkFIWC38xsS0,4681
+prompture/drivers/openai_driver.py,sha256=pO12D_4jmbCKkSDRLtk5olb7UqBqZyY0sh6IUJK1fjE,4371
+prompture/drivers/openrouter_driver.py,sha256=f4JWl3YApAgrvuskUz0athbdS82GZasclVKx1AA9-mA,5454
+prompture-0.0.33.dist-info/licenses/LICENSE,sha256=0HgDepH7aaHNFhHF-iXuW6_GqDfYPnVkjtiCAZ4yS8I,1060
+prompture-0.0.33.dist-info/METADATA,sha256=2hcu-U0S8qw5AIa5lPTwB6LV9RjhFhJfS6A2GC3X-sM,18109
+prompture-0.0.33.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+prompture-0.0.33.dist-info/entry_points.txt,sha256=AFPG3lJR86g4IJMoWQUW5Ph7G6MLNWG3A2u2Tp9zkp8,48
+prompture-0.0.33.dist-info/top_level.txt,sha256=to86zq_kjfdoLeAxQNr420UWqT0WzkKoZ509J7Qr2t4,10
+prompture-0.0.33.dist-info/RECORD,,

{prompture-0.0.32.dev1.dist-info → prompture-0.0.33.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

prompture-0.0.32.dev1.dist-info/RECORD

@@ -1,28 +0,0 @@
-prompture/__init__.py,sha256=kCcOseMTHaJkl-vtzXVbbBdWRQlIWWBr-C-l9E2mScU,2689
-prompture/cli.py,sha256=vA86GNjtKSHz8eRMl5YDaT9HHIWuhkeJtfx8jqTaqtM,809
-prompture/core.py,sha256=x_FhOY37ygQVHo4zHUyiWsV4BuOClkELsVhEV-K4jJ0,53689
-prompture/discovery.py,sha256=qQ7Quz0Tqo0f2h9DqMlV7RqMP4XOeue_ZwzXq4bf6B8,6788
-prompture/driver.py,sha256=w8pdXHujImIGF3ee8rkG8f6-UD0h2jLHhucSPInRrYI,989
-prompture/field_definitions.py,sha256=6kDMYNedccTK5l2L_I8_NI3_av-iYHqGPwkKDy8214c,21731
-prompture/runner.py,sha256=5xwal3iBQQj4_q7l3Rjr0e3RrUMJPaPDLiEchO0mmHo,4192
-prompture/settings.py,sha256=vHRkBAZNP6yRsI2Sm4FMa_FCw0Zxy2VX97ooiVYWvks,1500
-prompture/tools.py,sha256=qyT8oJl_v9GolABkflW0SvEx22yNkEJZKTu-40nJbs0,40329
-prompture/validator.py,sha256=oLzVsNveHuF-N_uOd11_uDa9Q5rFyo0wrk_l1N4zqDk,996
-prompture/drivers/__init__.py,sha256=IQ7DsWC_FP45h2CprWRhQ7lKi3-9ZO6CgweNX6IxTUA,3896
-prompture/drivers/azure_driver.py,sha256=GROhK3hqMfMurnEgpAawa1DPS-FhOU0YQcgy9SNGTzM,4622
-prompture/drivers/claude_driver.py,sha256=ZEHQNqNThLZ0p-WmGVuKiNyiudGYGP07xIzbgZhLY1g,3293
-prompture/drivers/google_driver.py,sha256=bCsCSuCRise0L_HOmw-jBh1hrpd8glNBkVFlOZeP0DM,6338
-prompture/drivers/grok_driver.py,sha256=Xp6L75oL3dN8St8_m46C_5bM8FcaIdNKUASAt9kZ39w,5003
-prompture/drivers/groq_driver.py,sha256=91WGXP8G5dO0beuFO8FehZszlDC_X9hv_yPzQRGmcqw,3920
-prompture/drivers/hugging_driver.py,sha256=rngz7hIR7l-9M_xe4EjWPaBqdyPFHdQsqnDDy9gm5So,2357
-prompture/drivers/lmstudio_driver.py,sha256=Umy1kT211TAxxSPyQrtZnIGIZgqFeSV87FLTiPFF0CY,3455
-prompture/drivers/local_http_driver.py,sha256=S2diikvtQOQHF7fB07zU2X0QWkej4Of__rJgaU2C6FI,1669
-prompture/drivers/ollama_driver.py,sha256=fq_eFgwmCT3SK1D-ICHjxLjcm_An0suwkFIWC38xsS0,4681
-prompture/drivers/openai_driver.py,sha256=9q9OjQslquRFvIl1Hd9JVmFFFVh6OBIWrFulw1mkYWg,3976
-prompture/drivers/openrouter_driver.py,sha256=GKvLOFDhsyopH-k3iaD3VWllm7xbGuopRSA02MfCKoM,5031
-prompture-0.0.32.dev1.dist-info/licenses/LICENSE,sha256=0HgDepH7aaHNFhHF-iXuW6_GqDfYPnVkjtiCAZ4yS8I,1060
-prompture-0.0.32.dev1.dist-info/METADATA,sha256=3oNb4hhkYR7ZuLsrG5wrRxJjbuLnazBaQHKaW2yAM0Y,18043
-prompture-0.0.32.dev1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-prompture-0.0.32.dev1.dist-info/entry_points.txt,sha256=AFPG3lJR86g4IJMoWQUW5Ph7G6MLNWG3A2u2Tp9zkp8,48
-prompture-0.0.32.dev1.dist-info/top_level.txt,sha256=to86zq_kjfdoLeAxQNr420UWqT0WzkKoZ509J7Qr2t4,10
-prompture-0.0.32.dev1.dist-info/RECORD,,