# Estimate API costs based on token usage
pricing = {
    "gemini-2.5-pro": {
        "input": 0.30,      # $0.30 per million tokens
        "output": 1.20      # $1.20 per million tokens
    },
    "gemini-2.5-flash": {
        "input": 0.10,
        "output": 0.40
    },
    "gemini-2.5-flash-lite": {
        "input": 0.04,
        "output": 0.12
    },
    "gemini-3-pro": {
        "input": 0.50,
        "output": 2.00
    },
    "gemini-3-flash": {
        "input": 0.15,
        "output": 0.60
    }
}
 
def estimate_cost(model_name, input_tokens, output_tokens):
    """Calculate estimated API usage cost"""
    rates = pricing.get(model_name, {})
    input_cost = (input_tokens / 1_000_000) * rates["input"]
    output_cost = (output_tokens / 1_000_000) * rates["output"]
    return input_cost + output_cost
 
# Example: 1M input tokens, 200K output tokens
cost_pro = estimate_cost("gemini-2.5-pro", 1_000_000, 200_000)
cost_flash = estimate_cost("gemini-2.5-flash", 1_000_000, 200_000)
cost_lite = estimate_cost("gemini-2.5-flash-lite", 1_000_000, 200_000)
 
print(f"2.5 Pro cost: ${cost_pro:.2f}")
print(f"2.5 Flash cost: ${cost_flash:.2f}")
print(f"2.5 Flash Lite cost: ${cost_lite:.2f}")

from anthropic import Anthropic
 
client = Anthropic()
 
# Complex coding tasks require Pro models
response = client.messages.create(
    model="gemini-2.5-pro",
    max_tokens=2048,
    messages=[{
        "role": "user",
        "content": """Implement a Python class that meets these requirements:
 
        1. Async HTTP client wrapper
        2. Retry logic with exponential backoff
        3. Request/response logging
        4. Timeout configuration
        5. Caching functionality
        """
    }]
)
 
print(response.content[0].text)

from anthropic import Anthropic
 
client = Anthropic()
 
# Text summarization works well with Flash
documents = [
    "Long news article...",
    "Technical blog post...",
    "Research paper abstract..."
]
 
for doc in documents:
    response = client.messages.create(
        model="gemini-2.5-flash",
        max_tokens=500,
        messages=[{
            "role": "user",
            "content": f"Summarize this text in 3 sentences:\n{doc}"
        }]
    )
    print(response.content[0].text)

from anthropic import Anthropic
 
client = Anthropic()
 
def stream_chat(user_message):
    """Real-time chat functionality"""
    with client.messages.stream(
        model="gemini-2.5-flash-lite",
        max_tokens=1024,
        messages=[{
            "role": "user",
            "content": user_message
        }]
    ) as stream:
        for text in stream.text_stream:
            print(text, end="", flush=True)
    print()
 
# Usage example
stream_chat("Briefly explain Python async/await")

from anthropic import Anthropic
 
client = Anthropic()
 
# Complex analysis requires latest Pro
response = client.messages.create(
    model="gemini-3-pro",
    max_tokens=2048,
    messages=[{
        "role": "user",
        "content": """Analyze market data and provide detailed explanation of:
 
        1. Current market trends
        2. Three major risk factors
        3. Recommended strategy
        4. Implementation roadmap
        """
    }]
)
 
print(response.content[0].text)

import base64
 
# Image analysis example
def analyze_image(image_path):
    """Analyze image content"""
    with open(image_path, "rb") as f:
        image_data = base64.standard_b64encode(f.read()).decode("utf-8")
 
    response = client.messages.create(
        model="gemini-2.5-pro",
        max_tokens=1024,
        messages=[{
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": "image/jpeg",
                        "data": image_data
                    }
                },
                {
                    "type": "text",
                    "text": "Describe all objects, text, and context in this image in detail"
                }
            ]
        }]
    )
 
    return response.content[0].text
 
# Usage example
analysis = analyze_image("chart.jpg")
print(analysis)

from anthropic import Anthropic
 
client = Anthropic()
 
def process_large_document(document_path, query):
    """Extract information from large documents"""
    # Load document
    with open(document_path, "r") as f:
        document_content = f.read()
 
    # Leverage 2M token context window
    response = client.messages.create(
        model="gemini-3-pro",
        max_tokens=1024,
        messages=[{
            "role": "user",
            "content": f"""Answer the question based on this document:
 
<document>
{document_content}
</document>
 
Question: {query}"""
        }]
    )
 
    return response.content[0].text
 
# Usage example
answer = process_large_document("annual_report.txt", "What were the key growth drivers in 2024?")
print(answer)

def smart_model_selection(task_type, input_tokens):
    """Select optimal model based on task complexity and tokens"""
 
    if input_tokens > 1_500_000:
        return "gemini-3-pro"  # Maximum context support
 
    complexity_to_model = {
        "simple_qa": "gemini-2.5-flash-lite",
        "chat": "gemini-2.5-flash",
        "analysis": "gemini-2.5-pro",
        "coding": "gemini-2.5-pro",
        "reasoning": "gemini-3-pro"
    }
 
    return complexity_to_model.get(task_type, "gemini-2.5-flash")
 
# Usage example
model = smart_model_selection("coding", 50000)
print(f"Selected model: {model}")

import json
from datetime import datetime
 
class APIUsageTracker:
    """Track API usage costs"""
 
    def __init__(self):
        self.usage_log = []
        self.pricing = {
            "gemini-2.5-pro": {"input": 0.30, "output": 1.20},
            "gemini-2.5-flash": {"input": 0.10, "output": 0.40},
        }
 
    def log_usage(self, model, input_tokens, output_tokens):
        """Log usage for cost tracking"""
        rates = self.pricing.get(model, {})
        cost = (input_tokens / 1_000_000) * rates["input"] + \
               (output_tokens / 1_000_000) * rates["output"]
 
        self.usage_log.append({
            "timestamp": datetime.now().isoformat(),
            "model": model,
            "input_tokens": input_tokens,
            "output_tokens": output_tokens,
            "cost": cost
        })
 
        return cost
 
    def get_daily_cost(self):
        """Calculate today's total cost"""
        today = datetime.now().date()
        today_usage = [u for u in self.usage_log
                      if datetime.fromisoformat(u["timestamp"]).date() == today]
        return sum(u["cost"] for u in today_usage)
 
# Usage example
tracker = APIUsageTracker()
cost = tracker.log_usage("gemini-2.5-flash", 50000, 10000)
print(f"Request cost: ${cost:.4f}")
print(f"Today's total: ${tracker.get_daily_cost():.2f}")