from anthropic import Anthropic
from pydantic import BaseModel
from typing import Optional

client = Anthropic()

class ProductAnalysis(BaseModel):
    sentiment: Literal["positive", "negative", "neutral"]
    score: float  # 0-1
    key_themes: list[str]
    summary: str
    requires_followup: bool
    followup_reason: Optional[str] = None

response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    messages=[{
        "role": "user",
        "content": f"Analyze this product review: {review_text}"
    }],
    # Force structured output matching our Pydantic model
    tools=[{
        "name": "product_analysis",
        "description": "Output the structured analysis of the review",
        "input_schema": ProductAnalysis.model_json_schema()
    }],
    tool_choice={"type": "tool", "name": "product_analysis"}
)

# Guaranteed to parse — no try/except needed for format errors
analysis = ProductAnalysis(**response.content[0].input)

from tenacity import retry, stop_after_attempt, wait_exponential
import anthropic
import openai

@retry(
    stop=stop_after_attempt(3),
    wait=wait_exponential(multiplier=1, min=2, max=10)
)
async def call_with_fallback(prompt: str, require_fast: bool = False) -> str:
    providers = [
        ("anthropic", "claude-sonnet-4-5"),
        ("openai", "gpt-4o"),
        ("anthropic", "claude-haiku-3-5"),  # Fast/cheap fallback
    ]
    
    last_error = None
    for provider, model in providers:
        try:
            if provider == "anthropic":
                client = anthropic.Anthropic()
                response = client.messages.create(
                    model=model,
                    max_tokens=1024,
                    messages=[{"role": "user", "content": prompt}]
                )
                return response.content[0].text
            elif provider == "openai":
                client = openai.OpenAI()
                response = client.chat.completions.create(
                    model=model,
                    messages=[{"role": "user", "content": prompt}]
                )
                return response.choices[0].message.content
        except Exception as e:
            last_error = e
            logger.warning(f"Provider {provider}/{model} failed: {e}")
            continue
    
    raise RuntimeError(f"All providers failed. Last error: {last_error}")

import hashlib
import redis
import json
from functools import wraps

redis_client = redis.Redis(host="localhost", port=6379)

def llm_cache(ttl: int = 3600, temperature_threshold: float = 0.0):
    """Cache LLM responses for deterministic or near-deterministic calls."""
    def decorator(func):
        @wraps(func)
        async def wrapper(*args, **kwargs):
            # Only cache zero-temperature calls (deterministic)
            temperature = kwargs.get("temperature", 0.0)
            if temperature > temperature_threshold:
                return await func(*args, **kwargs)
            
            # Create cache key from prompt + model
            cache_key = hashlib.sha256(
                json.dumps({"args": str(args), "kwargs": str(kwargs)}, 
                          sort_keys=True).encode()
            ).hexdigest()
            
            # Check cache
            cached = redis_client.get(f"llm:{cache_key}")
            if cached:
                return json.loads(cached)
            
            # Call LLM
            result = await func(*args, **kwargs)
            
            # Store in cache
            redis_client.setex(f"llm:{cache_key}", ttl, json.dumps(result))
            return result
        return wrapper
    return decorator

@llm_cache(ttl=86400)  # Cache for 24 hours
async def classify_text(text: str, model: str = "claude-haiku-3-5") -> dict:
    # ...

# LLM-as-judge pattern — use a strong model to evaluate a weaker one
async def evaluate_response(
    query: str, 
    response: str, 
    rubric: str
) -> dict:
    evaluation = await call_llm(
        system="""You are an evaluator. Rate the response on the given rubric.
        Return JSON with: score (1-5), reasoning (string), 
        passes_minimum (bool).""",
        user=f"""Query: {query}
        
        Response: {response}
        
        Rubric: {rubric}"""
    )
    return json.loads(evaluation)

# Build a test suite
test_cases = [
    {"query": "...", "expected_themes": [...], "should_require_followup": True},
    # ...
]

# Run evaluations on every prompt change
async def regression_test(prompt_version: str):
    results = []
    for case in test_cases:
        output = await run_pipeline(case["query"], prompt_version)
        score = await evaluate_response(
            case["query"], 
            output, 
            rubric=EVALUATION_RUBRIC
        )
        results.append(score)
    
    pass_rate = sum(r["passes_minimum"] for r in results) / len(results)
    return pass_rate