prompture 0.0.31.dev1__tar.gz → 0.0.32.dev1__tar.gz

{prompture-0.0.31.dev1 → prompture-0.0.32.dev1}/.github/scripts/update_docs_version.py

@@ -142,39 +142,34 @@ def update_index_rst(index_file, version):
         content = index_file.read_text(encoding='utf-8')
         lines = content.splitlines(keepends=True)
         
-        # Pattern to match the version line (line 20, 0-indexed as 19)
+        # Pattern to match the version line
         pattern = re.compile(
             r'^(\s*Prompture is currently in development \(version )'
             r'[^)]+' 
             r'(\)\. APIs may change between versions\.\s*)$'
         )
         
-        # Update line 20 (index 19)
-        if len(lines) >= 20:
-            line_idx = 19  # Line 20 is at index 19
-            original_line = lines[line_idx]
-            
-            # Check if the line matches the expected pattern
-            if pattern.match(original_line):
+        updated = False
+        for i, line in enumerate(lines):
+            if pattern.match(line):
                 # Replace with new version
                 new_line = pattern.sub(
                     rf'\g<1>{version}\g<2>',
-                    original_line
+                    line
                 )
-                lines[line_idx] = new_line
-                
-                # Write back to file
-                index_file.write_text(''.join(lines), encoding='utf-8')
-                print(f"✓ Updated version in {index_file}")
-                print(f"  Old: {original_line.strip()}")
+                lines[i] = new_line
+                print(f"✓ Updated version in {index_file} at line {i+1}")
+                print(f"  Old: {line.strip()}")
                 print(f"  New: {new_line.strip()}")
-                return True
-            else:
-                print(f"✗ Line 20 does not match expected pattern", file=sys.stderr)
-                print(f"  Found: {original_line.strip()}", file=sys.stderr)
-                return False
+                updated = True
+                break
+        
+        if updated:
+            # Write back to file
+            index_file.write_text(''.join(lines), encoding='utf-8')
+            return True
         else:
-            print(f"✗ File has fewer than 20 lines", file=sys.stderr)
+            print(f"✗ Version pattern not found in {index_file}", file=sys.stderr)
             return False
             
     except Exception as e:

{prompture-0.0.31.dev1 → prompture-0.0.32.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompture
-Version: 0.0.31.dev1
+Version: 0.0.32.dev1
 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 → prompture-0.0.32.dev1}/README.md

@@ -18,8 +18,7 @@
 - ✅ **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]
@@ -79,6 +78,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 → prompture-0.0.32.dev1}/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-0.0.31.dev1 → prompture-0.0.32.dev1}/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-0.0.32.dev1/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 → prompture-0.0.32.dev1}/prompture.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompture
-Version: 0.0.31.dev1
+Version: 0.0.32.dev1
 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 → prompture-0.0.32.dev1}/prompture.egg-info/SOURCES.txt

@@ -41,6 +41,7 @@ packages/llm_to_toon/llm_to_toon/__init__.py
 prompture/__init__.py
 prompture/cli.py
 prompture/core.py
+prompture/discovery.py
 prompture/driver.py
 prompture/field_definitions.py
 prompture/runner.py