# Unit prices in $ per million tokens (verify against current pricing)
pricing = {
    "gemini-2.5-pro": {"input": 0.30, "output": 1.20},
    "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):
    """Estimate API usage cost."""
    rates = pricing.get(model_name)
    if rates is None:
        raise ValueError(f"Unknown model: {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
for m in ("gemini-2.5-pro", "gemini-2.5-flash", "gemini-2.5-flash-lite"):
    print(f"{m}: ${estimate_cost(m, 1_000_000, 200_000):.2f}")

from google import genai
from google.genai import types
 
# The key can also be read from the GEMINI_API_KEY environment variable
client = genai.Client(api_key="YOUR_GEMINI_API_KEY")

response = client.models.generate_content(
    model="gemini-2.5-pro",
    contents="""Implement a Python class that meets these requirements:
 
    1. An async HTTP client wrapper
    2. Retry logic (exponential backoff)
    3. Request/response logging
    4. Timeout configuration
    5. Caching
    """,
    config=types.GenerateContentConfig(max_output_tokens=2048),
)
print(response.text)

documents = [
    "A long news article...",
    "A technical blog post...",
    "A research paper abstract...",
]
 
for doc in documents:
    response = client.models.generate_content(
        model="gemini-2.5-flash",
        contents=f"Summarize the following text in three sentences:\n{doc}",
        config=types.GenerateContentConfig(max_output_tokens=500),
    )
    print(response.text)

def stream_chat(user_message):
    """Real-time chat."""
    for chunk in client.models.generate_content_stream(
        model="gemini-2.5-flash-lite",
        contents=user_message,
        config=types.GenerateContentConfig(max_output_tokens=1024),
    ):
        if chunk.text:
            print(chunk.text, end="", flush=True)
    print()
 
stream_chat("Briefly explain async/await in Python")

response = client.models.generate_content(
    model="gemini-3-pro",
    contents="""Analyze the market data and explain the following in detail:
 
    1. Current market trends
    2. Three major risk factors
    3. A recommended strategy
    4. An implementation roadmap
    """,
    config=types.GenerateContentConfig(max_output_tokens=2048),
)
print(response.text)

def analyze_image(image_path):
    """Analyze an image."""
    with open(image_path, "rb") as f:
        image_bytes = f.read()
 
    response = client.models.generate_content(
        model="gemini-2.5-pro",
        contents=[
            types.Part.from_bytes(data=image_bytes, mime_type="image/jpeg"),
            "Describe the objects, text, and context in this image in detail",
        ],
        config=types.GenerateContentConfig(max_output_tokens=1024),
    )
    return response.text
 
print(analyze_image("chart.jpg"))

def process_large_document(document_path, query):
    """Extract information from a large document."""
    with open(document_path, "r", encoding="utf-8") as f:
        document_content = f.read()
 
    response = client.models.generate_content(
        model="gemini-3-pro",
        contents=f"""Answer the question based on the document below:
 
<document>
{document_content}
</document>
 
Question: {query}""",
        config=types.GenerateContentConfig(max_output_tokens=1024),
    )
    return response.text
 
print(process_large_document("annual_report.txt", "What were the main growth drivers in 2024?"))

def smart_model_selection(task_type, input_tokens):
    """Pick a model based on task complexity and token count."""
    if input_tokens > 1_500_000:
        return "gemini-3-pro"  # max context
 
    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")
 
print(smart_model_selection("coding", 50_000))

from datetime import datetime
 
class APIUsageTracker:
    """Track API usage cost."""
 
    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_response(self, model, response):
        """Record cost from a response's actual token counts."""
        usage = response.usage_metadata
        input_tokens = usage.prompt_token_count
        output_tokens = usage.candidates_token_count
        rates = self.pricing.get(model, {"input": 0, "output": 0})
        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):
        """Compute today's cost."""
        today = datetime.now().date()
        return sum(
            u["cost"] for u in self.usage_log
            if datetime.fromisoformat(u["timestamp"]).date() == today
        )