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

prompture/__init__.py

@@ -11,7 +11,9 @@ from .core import (
     stepwise_extract_with_model,
     extract_from_data,
     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 .tools import clean_json_text, clean_toon_text
 from .field_definitions import (
     FIELD_DEFINITIONS, get_field_definition, get_required_fields, get_field_names,
@@ -21,6 +23,7 @@ from .field_definitions import (
 )
 from .runner import run_suite_from_spec
 from .validator import validate_against_schema
+from .discovery import get_available_models
 
 # Load environment variables from .env file
 load_dotenv()
@@ -54,6 +57,7 @@ __all__ = [
     # TOON Data Extraction Functions
     "extract_from_data",
     "extract_from_pandas",
+    "render_output",
     # Field Definitions
     "FIELD_DEFINITIONS",
     "get_field_definition",
@@ -70,4 +74,19 @@ __all__ = [
     # Enum Field Support
     "validate_enum_value",
     "normalize_enum_value",
+    # Drivers
+    "get_driver",
+    "get_driver_for_model",
+    "OpenAIDriver",
+    "LocalHTTPDriver",
+    "OllamaDriver",
+    "ClaudeDriver",
+    "LMStudioDriver",
+    "AzureDriver",
+    "GoogleDriver",
+    "GroqDriver",
+    "OpenRouterDriver",
+    "GrokDriver",
+    # Discovery
+    "get_available_models",
 ]

prompture/core.py

@@ -129,6 +129,90 @@ def clean_json_text_with_ai(driver: Driver, text: str, model_name: str = "", opt
     cleaned = clean_json_text(raw)
     return cleaned
 
+
+def render_output(
+    driver: Driver,
+    content_prompt: str,
+    output_format: Literal["text", "html", "markdown"] = "text",
+    model_name: str = "",
+    options: Dict[str, Any] = {},
+) -> Dict[str, Any]:
+    """Sends a prompt to the driver and returns the raw output in the requested format.
+
+    This function is designed for "no fluff" output, instructing the LLM to return
+    only the requested content without conversational filler or markdown fences
+    (unless markdown is requested).
+
+    Args:
+        driver: Adapter that implements generate(prompt, options).
+        content_prompt: Main prompt content.
+        output_format: Desired format ("text", "html", "markdown").
+        model_name: Optional model identifier used in usage metadata.
+        options: Additional options to pass to the driver.
+
+    Returns:
+        A dictionary containing:
+        - text: the raw text output.
+        - usage: token usage and cost information from the driver's meta object.
+        - output_format: the format of the output.
+
+    Raises:
+        ValueError: If an unsupported output format is provided.
+    """
+    if output_format not in ("text", "html", "markdown"):
+        raise ValueError(f"Unsupported output_format '{output_format}'. Use 'text', 'html', or 'markdown'.")
+
+    instruct = ""
+    if output_format == "text":
+        instruct = (
+            "Return ONLY the raw text content. Do not use markdown formatting, "
+            "code fences, or conversational filler. Just the text."
+        )
+    elif output_format == "html":
+        instruct = (
+            "Return ONLY valid HTML code. Do not wrap it in markdown code fences "
+            "(like ```html ... ```). Do not include conversational filler."
+        )
+    elif output_format == "markdown":
+        instruct = (
+            "Return valid markdown content. You may use standard markdown formatting."
+        )
+
+    full_prompt = f"{content_prompt}\n\nSYSTEM INSTRUCTION: {instruct}"
+    
+    # If specific options are needed for certain formats, they could be added here
+    # For now, we pass options through
+    
+    resp = driver.generate(full_prompt, options)
+    raw = resp.get("text", "")
+    
+    # Clean up potential markdown fences if the model disobeyed for text/html
+    if output_format in ("text", "html"):
+        # Simple cleanup for common fences if they appear despite instructions
+        cleaned = raw.strip()
+        if cleaned.startswith("```") and cleaned.endswith("```"):
+            # Remove first line (fence + optional language) and last line (fence)
+            lines = cleaned.splitlines()
+            if len(lines) >= 2:
+                cleaned = "\n".join(lines[1:-1])
+        raw = cleaned
+
+    usage = {
+        **resp.get("meta", {}),
+        "raw_response": resp,
+        "total_tokens": resp.get("meta", {}).get("total_tokens", 0),
+        "prompt_tokens": resp.get("meta", {}).get("prompt_tokens", 0),
+        "completion_tokens": resp.get("meta", {}).get("completion_tokens", 0),
+        "cost": resp.get("meta", {}).get("cost", 0.0),
+        "model_name": model_name or getattr(driver, "model", "")
+    }
+    
+    return {
+        "text": raw,
+        "usage": usage,
+        "output_format": output_format
+    }
+
 def ask_for_json(
     driver: Driver,
     content_prompt: str,

prompture/discovery.py

@@ -0,0 +1,149 @@
+"""Discovery module for auto-detecting available models."""
+import os
+import requests
+import logging
+from typing import List, Dict, Any, Set
+
+from .drivers import (
+    DRIVER_REGISTRY,
+    OpenAIDriver,
+    AzureDriver,
+    ClaudeDriver,
+    GoogleDriver,
+    GroqDriver,
+    OpenRouterDriver,
+    GrokDriver,
+    OllamaDriver,
+    LMStudioDriver,
+    LocalHTTPDriver,
+)
+from .settings import settings
+
+logger = logging.getLogger(__name__)
+
+def get_available_models() -> List[str]:
+    """
+    Auto-detects all available models based on configured drivers and environment variables.
+    
+    Iterates through supported providers and checks if they are configured (e.g. API key present).
+    For static drivers, returns models from their MODEL_PRICING keys.
+    For dynamic drivers (like Ollama), attempts to fetch available models from the endpoint.
+    
+    Returns:
+        A list of unique model strings in the format "provider/model_id".
+    """
+    available_models: 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.
+    provider_classes = {
+        "openai": OpenAIDriver,
+        "azure": AzureDriver,
+        "claude": ClaudeDriver,
+        "google": GoogleDriver,
+        "groq": GroqDriver,
+        "openrouter": OpenRouterDriver,
+        "grok": GrokDriver,
+        "ollama": OllamaDriver,
+        "lmstudio": LMStudioDriver,
+        "local_http": LocalHTTPDriver,
+    }
+
+    for provider, driver_cls in provider_classes.items():
+        try:
+            # 1. Check if the provider is configured (has API key or endpoint)
+            # We can check this by looking at the settings or env vars that the driver uses.
+            # A simple way is to try to instantiate it with defaults, but that might fail if keys are missing.
+            # Instead, let's check the specific requirements for each known provider.
+            
+            is_configured = False
+            
+            if provider == "openai":
+                if settings.openai_api_key or os.getenv("OPENAI_API_KEY"):
+                    is_configured = True
+            elif provider == "azure":
+                if (settings.azure_api_key or os.getenv("AZURE_API_KEY")) and \
+                   (settings.azure_api_endpoint or os.getenv("AZURE_API_ENDPOINT")) and \
+                   (settings.azure_deployment_id or os.getenv("AZURE_DEPLOYMENT_ID")):
+                    is_configured = True
+            elif provider == "claude":
+                if settings.claude_api_key or os.getenv("CLAUDE_API_KEY"):
+                    is_configured = True
+            elif provider == "google":
+                if settings.google_api_key or os.getenv("GOOGLE_API_KEY"):
+                    is_configured = True
+            elif provider == "groq":
+                if settings.groq_api_key or os.getenv("GROQ_API_KEY"):
+                    is_configured = True
+            elif provider == "openrouter":
+                if settings.openrouter_api_key or os.getenv("OPENROUTER_API_KEY"):
+                    is_configured = True
+            elif provider == "grok":
+                if settings.grok_api_key or os.getenv("GROK_API_KEY"):
+                    is_configured = True
+            elif provider == "ollama":
+                # Ollama is always considered "configured" as it defaults to localhost
+                # We will check connectivity later
+                is_configured = True
+            elif provider == "lmstudio":
+                 # LM Studio is similar to Ollama, defaults to localhost
+                 is_configured = True
+            elif provider == "local_http":
+                 if settings.local_http_endpoint or os.getenv("LOCAL_HTTP_ENDPOINT"):
+                     is_configured = True
+
+            if not is_configured:
+                continue
+
+            # 2. Static Detection: Get models from MODEL_PRICING
+            if hasattr(driver_cls, "MODEL_PRICING"):
+                pricing = driver_cls.MODEL_PRICING
+                for model_id in pricing.keys():
+                    # Skip "default" or generic keys if they exist
+                    if model_id == "default":
+                        continue
+                    
+                    # For Azure, the model_id in pricing is usually the base model name, 
+                    # but the user needs to use the deployment ID. 
+                    # However, our Azure driver implementation uses the deployment_id from init 
+                    # as the "model" for the request, but expects the user to pass a model name 
+                    # that maps to pricing? 
+                    # Looking at AzureDriver:
+                    # kwargs = {"model": self.deployment_id, ...}
+                    # model = options.get("model", self.model) -> used for pricing lookup
+                    # So we should list the keys in MODEL_PRICING as available "models" 
+                    # even though for Azure specifically it's a bit weird because of deployment IDs.
+                    # But for general discovery, listing supported models is correct.
+                    
+                    available_models.add(f"{provider}/{model_id}")
+
+            # 3. Dynamic Detection: Specific logic for Ollama
+            if provider == "ollama":
+                try:
+                    endpoint = settings.ollama_endpoint or os.getenv("OLLAMA_ENDPOINT", "http://localhost:11434/api/generate")
+                    # We need the base URL for tags, usually http://localhost:11434/api/tags
+                    # The configured endpoint might be .../api/generate or .../api/chat
+                    base_url = endpoint.split("/api/")[0]
+                    tags_url = f"{base_url}/api/tags"
+                    
+                    resp = requests.get(tags_url, timeout=2)
+                    if resp.status_code == 200:
+                        data = resp.json()
+                        models = data.get("models", [])
+                        for model in models:
+                            name = model.get("name")
+                            if name:
+                                # Ollama model names often include tags like "llama3:latest"
+                                # We can keep them as is.
+                                available_models.add(f"ollama/{name}")
+                except Exception as e:
+                    logger.debug(f"Failed to fetch Ollama models: {e}")
+            
+            # Future: Add dynamic detection for LM Studio if they have an endpoint for listing models
+            
+        except Exception as e:
+            logger.warning(f"Error detecting models for provider {provider}: {e}")
+            continue
+
+    return sorted(list(available_models))

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompture
-Version: 0.0.31.dev1
+Version: 0.0.32
 Summary: Ask LLMs to return structured JSON and run cross-model tests. API-first.
 Home-page: https://github.com/jhd3197/prompture
 Author: Juan Denis
@@ -61,8 +61,7 @@ Dynamic: summary
 - ✅ **Usage & cost** → Token + $ tracking on every call (`usage` from driver meta)
 - ✅ **AI cleanup** → Optional LLM pass to fix malformed JSON
 - ✅ **Batch testing** → Define suites and compare models (spec-driven)
-- 🧪 **Experimental TOON output** → Request Token-Oriented Object Notation when you need ultra-compact text (see [analysis](toon_token_analysis.md))
-
+- 🧪 **Experimental TOON output** → Request Token-Oriented Object Notation when you need ultra-compact text
 <br>
 
 > [!TIP]
@@ -122,6 +121,25 @@ export LMSTUDIO_ENDPOINT=...
 
 ---
 
+## 🔍 Model Discovery
+
+Prompture can auto-detect available models from your configured environment. This is especially useful for local setups (like Ollama) or when you want to see which models are available to your application.
+
+```python
+from prompture import get_available_models
+
+# Returns a list of strings like ["openai/gpt-4o", "ollama/llama3:latest", ...]
+models = get_available_models()
+
+for model in models:
+    print(f"Found: {model}")
+```
+
+- **Static Drivers** (OpenAI, Claude, Azure, etc.): Returns models listed in the driver's `MODEL_PRICING` configuration if the driver is configured (API key present).
+- **Dynamic Drivers** (Ollama): Queries the local endpoint (e.g., `http://localhost:11434/api/tags`) to fetch currently installed models.
+
+---
+
 ## Quickstart: Pydantic in one line (auto driver)
 
 Use `extract_with_model` for a single LLM call that fills your Pydantic model.

{prompture-0.0.31.dev1.dist-info → prompture-0.0.32.dist-info}/RECORD

@@ -1,6 +1,7 @@
-prompture/__init__.py,sha256=aWlRheKlKjFh2v0FifG52hgEXthsFZLcMd7qlYzdnoc,2099
+prompture/__init__.py,sha256=kCcOseMTHaJkl-vtzXVbbBdWRQlIWWBr-C-l9E2mScU,2689
 prompture/cli.py,sha256=vA86GNjtKSHz8eRMl5YDaT9HHIWuhkeJtfx8jqTaqtM,809
-prompture/core.py,sha256=Er08vBlkL7Ho4LmqR6-B9q7ILLNMJB059yx6TBg_Xu4,50448
+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
@@ -19,9 +20,9 @@ prompture/drivers/local_http_driver.py,sha256=S2diikvtQOQHF7fB07zU2X0QWkej4Of__r
 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.31.dev1.dist-info/licenses/LICENSE,sha256=0HgDepH7aaHNFhHF-iXuW6_GqDfYPnVkjtiCAZ4yS8I,1060
-prompture-0.0.31.dev1.dist-info/METADATA,sha256=jjKlX4Bjrf5zA3_QJcMwBcO0fVFn8eIVkjIcJZslTCI,17320
-prompture-0.0.31.dev1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-prompture-0.0.31.dev1.dist-info/entry_points.txt,sha256=AFPG3lJR86g4IJMoWQUW5Ph7G6MLNWG3A2u2Tp9zkp8,48
-prompture-0.0.31.dev1.dist-info/top_level.txt,sha256=to86zq_kjfdoLeAxQNr420UWqT0WzkKoZ509J7Qr2t4,10
-prompture-0.0.31.dev1.dist-info/RECORD,,
+prompture-0.0.32.dist-info/licenses/LICENSE,sha256=0HgDepH7aaHNFhHF-iXuW6_GqDfYPnVkjtiCAZ4yS8I,1060
+prompture-0.0.32.dist-info/METADATA,sha256=3zIIVSr4TWQDG-PUKxoK5WwPtm-jAZ_LRn5WFJsYaQo,18038
+prompture-0.0.32.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+prompture-0.0.32.dist-info/entry_points.txt,sha256=AFPG3lJR86g4IJMoWQUW5Ph7G6MLNWG3A2u2Tp9zkp8,48
+prompture-0.0.32.dist-info/top_level.txt,sha256=to86zq_kjfdoLeAxQNr420UWqT0WzkKoZ509J7Qr2t4,10
+prompture-0.0.32.dist-info/RECORD,,