ccproxy-api 0.1.0__py3-none-any.whl

ccproxy/observability/storage/models.py

@@ -0,0 +1,55 @@
+"""
+SQLModel schema definitions for observability storage.
+
+This module provides the centralized schema definitions for access logs and metrics
+using SQLModel to ensure type safety and eliminate column name repetition.
+"""
+
+from datetime import datetime
+from typing import Optional
+
+from sqlmodel import Field, SQLModel
+
+
+class AccessLog(SQLModel, table=True):
+    """Access log model for storing request/response data."""
+
+    __tablename__ = "access_logs"
+
+    # Core request identification
+    request_id: str = Field(primary_key=True)
+    timestamp: datetime = Field(default_factory=datetime.now, index=True)
+
+    # Request details
+    method: str
+    endpoint: str
+    path: str
+    query: str = Field(default="")
+    client_ip: str
+    user_agent: str
+
+    # Service and model info
+    service_type: str
+    model: str
+    streaming: bool = Field(default=False)
+
+    # Response details
+    status_code: int
+    duration_ms: float
+    duration_seconds: float
+
+    # Token and cost tracking
+    tokens_input: int = Field(default=0)
+    tokens_output: int = Field(default=0)
+    cache_read_tokens: int = Field(default=0)
+    cache_write_tokens: int = Field(default=0)
+    cost_usd: float = Field(default=0.0)
+    cost_sdk_usd: float = Field(default=0.0)
+
+    class Config:
+        """SQLModel configuration."""
+
+        # Enable automatic conversion from dict
+        from_attributes = True
+        # Use enum values
+        use_enum_values = True

ccproxy/pricing/__init__.py

@@ -0,0 +1,19 @@
+"""Dynamic pricing system for Claude models.
+
+This module provides dynamic pricing capabilities by downloading and caching
+pricing information from external sources like LiteLLM.
+"""
+
+from .cache import PricingCache
+from .loader import PricingLoader
+from .models import ModelPricing, PricingData
+from .updater import PricingUpdater
+
+
+__all__ = [
+    "PricingCache",
+    "PricingLoader",
+    "PricingUpdater",
+    "ModelPricing",
+    "PricingData",
+]

ccproxy/pricing/cache.py

@@ -0,0 +1,212 @@
+"""Pricing cache management for dynamic model pricing."""
+
+import json
+import time
+from pathlib import Path
+from typing import Any
+
+import httpx
+from structlog import get_logger
+
+from ccproxy.config.pricing import PricingSettings
+
+
+logger = get_logger(__name__)
+
+
+class PricingCache:
+    """Manages caching of model pricing data from external sources."""
+
+    def __init__(self, settings: PricingSettings) -> None:
+        """Initialize pricing cache.
+
+        Args:
+            settings: Pricing configuration settings
+        """
+        self.settings = settings
+        self.cache_dir = settings.cache_dir
+        self.cache_file = self.cache_dir / "model_pricing.json"
+
+        # Ensure cache directory exists
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+    def is_cache_valid(self) -> bool:
+        """Check if cached pricing data is still valid.
+
+        Returns:
+            True if cache exists and is not expired
+        """
+        if not self.cache_file.exists():
+            return False
+
+        try:
+            stat = self.cache_file.stat()
+            age_seconds = time.time() - stat.st_mtime
+            age_hours = age_seconds / 3600
+
+            is_valid = age_hours < self.settings.cache_ttl_hours
+            return is_valid
+
+        except OSError as e:
+            logger.warning("cache_stats_check_failed", error=str(e))
+            return False
+
+    def load_cached_data(self) -> dict[str, Any] | None:
+        """Load pricing data from cache.
+
+        Returns:
+            Cached pricing data or None if cache is invalid/corrupted
+        """
+        if not self.is_cache_valid():
+            return None
+
+        try:
+            with self.cache_file.open(encoding="utf-8") as f:
+                data = json.load(f)
+
+            return data  # type: ignore[no-any-return]
+
+        except (OSError, json.JSONDecodeError) as e:
+            logger.warning("cache_load_failed", error=str(e))
+            return None
+
+    async def download_pricing_data(
+        self, timeout: int | None = None
+    ) -> dict[str, Any] | None:
+        """Download fresh pricing data from source URL.
+
+        Args:
+            timeout: Request timeout in seconds (uses settings default if None)
+
+        Returns:
+            Downloaded pricing data or None if download failed
+        """
+        if timeout is None:
+            timeout = self.settings.download_timeout
+
+        try:
+            logger.info("pricing_download_start", url=self.settings.source_url)
+
+            async with httpx.AsyncClient(timeout=timeout) as client:
+                response = await client.get(self.settings.source_url)
+                response.raise_for_status()
+
+                data = response.json()
+                logger.info("pricing_download_completed", model_count=len(data))
+                return data  # type: ignore[no-any-return]
+
+        except (httpx.HTTPError, json.JSONDecodeError) as e:
+            logger.error("pricing_download_failed", error=str(e))
+            return None
+
+    def save_to_cache(self, data: dict[str, Any]) -> bool:
+        """Save pricing data to cache.
+
+        Args:
+            data: Pricing data to cache
+
+        Returns:
+            True if successfully saved, False otherwise
+        """
+        try:
+            # Write to temporary file first, then atomic rename
+            temp_file = self.cache_file.with_suffix(".tmp")
+
+            with temp_file.open("w", encoding="utf-8") as f:
+                json.dump(data, f, indent=2)
+
+            # Atomic rename
+            temp_file.replace(self.cache_file)
+
+            return True
+
+        except OSError as e:
+            logger.error("cache_save_failed", error=str(e))
+            return False
+
+    async def get_pricing_data(
+        self, force_refresh: bool = False
+    ) -> dict[str, Any] | None:
+        """Get pricing data, from cache if valid or by downloading fresh data.
+
+        Args:
+            force_refresh: Force download even if cache is valid
+
+        Returns:
+            Pricing data or None if both cache and download fail
+        """
+        # Try cache first unless forced refresh
+        if not force_refresh:
+            cached_data = self.load_cached_data()
+            if cached_data is not None:
+                return cached_data
+
+        # Download fresh data
+        fresh_data = await self.download_pricing_data()
+        if fresh_data is not None:
+            # Save to cache for next time
+            self.save_to_cache(fresh_data)
+            return fresh_data
+
+        # If download failed, try to use stale cache as fallback
+        if not force_refresh:
+            logger.warning("pricing_download_failed_using_stale_cache")
+            try:
+                with self.cache_file.open(encoding="utf-8") as f:
+                    stale_data = json.load(f)
+                logger.warning("stale_cache_used")
+                return stale_data  # type: ignore[no-any-return]
+            except (OSError, json.JSONDecodeError):
+                pass
+
+        logger.error("pricing_data_unavailable")
+        return None
+
+    def clear_cache(self) -> bool:
+        """Clear cached pricing data.
+
+        Returns:
+            True if cache was cleared successfully
+        """
+        try:
+            if self.cache_file.exists():
+                self.cache_file.unlink()
+            return True
+        except OSError as e:
+            logger.error("cache_clear_failed", error=str(e))
+            return False
+
+    def get_cache_info(self) -> dict[str, Any]:
+        """Get information about cache status.
+
+        Returns:
+            Dictionary with cache information
+        """
+        info = {
+            "cache_file": str(self.cache_file),
+            "cache_dir": str(self.cache_dir),
+            "source_url": self.settings.source_url,
+            "ttl_hours": self.settings.cache_ttl_hours,
+            "exists": self.cache_file.exists(),
+            "valid": False,
+            "age_hours": None,
+            "size_bytes": None,
+        }
+
+        if self.cache_file.exists():
+            try:
+                stat = self.cache_file.stat()
+                age_seconds = time.time() - stat.st_mtime
+                age_hours = age_seconds / 3600
+
+                info.update(
+                    {
+                        "valid": age_hours < self.settings.cache_ttl_hours,
+                        "age_hours": age_hours,
+                        "size_bytes": stat.st_size,
+                    }
+                )
+            except OSError:
+                pass
+
+        return info

ccproxy/pricing/loader.py

@@ -0,0 +1,267 @@
+"""Pricing data loader and format converter for LiteLLM pricing data."""
+
+from decimal import Decimal
+from typing import Any
+
+from pydantic import ValidationError
+from structlog import get_logger
+
+from .models import PricingData
+
+
+logger = get_logger(__name__)
+
+
+class PricingLoader:
+    """Loads and converts pricing data from LiteLLM format to internal format."""
+
+    # Claude model name mappings for different versions
+    CLAUDE_MODEL_MAPPINGS = {
+        # Map versioned models to their canonical names
+        "claude-3-5-sonnet-latest": "claude-3-5-sonnet-20241022",
+        "claude-3-5-sonnet-20240620": "claude-3-5-sonnet-20240620",
+        "claude-3-5-sonnet-20241022": "claude-3-5-sonnet-20241022",
+        "claude-3-5-haiku-latest": "claude-3-5-haiku-20241022",
+        "claude-3-5-haiku-20241022": "claude-3-5-haiku-20241022",
+        "claude-3-opus": "claude-3-opus-20240229",
+        "claude-3-opus-20240229": "claude-3-opus-20240229",
+        "claude-3-sonnet": "claude-3-sonnet-20240229",
+        "claude-3-sonnet-20240229": "claude-3-sonnet-20240229",
+        "claude-3-haiku": "claude-3-haiku-20240307",
+        "claude-3-haiku-20240307": "claude-3-haiku-20240307",
+    }
+
+    @staticmethod
+    def extract_claude_models(
+        litellm_data: dict[str, Any], verbose: bool = True
+    ) -> dict[str, Any]:
+        """Extract Claude model entries from LiteLLM data.
+
+        Args:
+            litellm_data: Raw LiteLLM pricing data
+            verbose: Whether to log individual model discoveries
+
+        Returns:
+            Dictionary with only Claude models
+        """
+        claude_models = {}
+
+        for model_name, model_data in litellm_data.items():
+            # Check if this is a Claude model
+            if (
+                isinstance(model_data, dict)
+                and model_data.get("litellm_provider") == "anthropic"
+                and "claude" in model_name.lower()
+            ):
+                claude_models[model_name] = model_data
+                if verbose:
+                    logger.debug("claude_model_found", model_name=model_name)
+
+        if verbose:
+            logger.info(
+                "claude_models_extracted",
+                model_count=len(claude_models),
+                source="LiteLLM",
+            )
+        return claude_models
+
+    @staticmethod
+    def convert_to_internal_format(
+        claude_models: dict[str, Any], verbose: bool = True
+    ) -> dict[str, dict[str, Decimal]]:
+        """Convert LiteLLM pricing format to internal format.
+
+        LiteLLM format uses cost per token, we use cost per 1M tokens as Decimal.
+
+        Args:
+            claude_models: Claude models in LiteLLM format
+            verbose: Whether to log individual model conversions
+
+        Returns:
+            Dictionary in internal pricing format
+        """
+        internal_format = {}
+
+        for model_name, model_data in claude_models.items():
+            try:
+                # Extract pricing fields
+                input_cost_per_token = model_data.get("input_cost_per_token")
+                output_cost_per_token = model_data.get("output_cost_per_token")
+                cache_creation_cost = model_data.get("cache_creation_input_token_cost")
+                cache_read_cost = model_data.get("cache_read_input_token_cost")
+
+                # Skip models without pricing info
+                if input_cost_per_token is None or output_cost_per_token is None:
+                    if verbose:
+                        logger.warning("model_pricing_missing", model_name=model_name)
+                    continue
+
+                # Convert to per-1M-token pricing (multiply by 1,000,000)
+                pricing = {
+                    "input": Decimal(str(input_cost_per_token * 1_000_000)),
+                    "output": Decimal(str(output_cost_per_token * 1_000_000)),
+                }
+
+                # Add cache pricing if available
+                if cache_creation_cost is not None:
+                    pricing["cache_write"] = Decimal(
+                        str(cache_creation_cost * 1_000_000)
+                    )
+
+                if cache_read_cost is not None:
+                    pricing["cache_read"] = Decimal(str(cache_read_cost * 1_000_000))
+
+                # Map to canonical model name if needed
+                canonical_name = PricingLoader.CLAUDE_MODEL_MAPPINGS.get(
+                    model_name, model_name
+                )
+                internal_format[canonical_name] = pricing
+
+                if verbose:
+                    logger.debug(
+                        "model_pricing_converted",
+                        original_name=model_name,
+                        canonical_name=canonical_name,
+                        input_cost=str(pricing["input"]),
+                        output_cost=str(pricing["output"]),
+                    )
+
+            except (ValueError, TypeError) as e:
+                if verbose:
+                    logger.error(
+                        "pricing_conversion_failed", model_name=model_name, error=str(e)
+                    )
+                continue
+
+        if verbose:
+            logger.info("models_converted", model_count=len(internal_format))
+        return internal_format
+
+    @staticmethod
+    def load_pricing_from_data(
+        litellm_data: dict[str, Any], verbose: bool = True
+    ) -> PricingData | None:
+        """Load and convert pricing data from LiteLLM format.
+
+        Args:
+            litellm_data: Raw LiteLLM pricing data
+            verbose: Whether to enable verbose logging
+
+        Returns:
+            Validated pricing data as PricingData model, or None if invalid
+        """
+        try:
+            # Extract Claude models
+            claude_models = PricingLoader.extract_claude_models(
+                litellm_data, verbose=verbose
+            )
+
+            if not claude_models:
+                if verbose:
+                    logger.warning("claude_models_not_found", source="LiteLLM")
+                return None
+
+            # Convert to internal format
+            internal_pricing = PricingLoader.convert_to_internal_format(
+                claude_models, verbose=verbose
+            )
+
+            if not internal_pricing:
+                if verbose:
+                    logger.warning("pricing_data_invalid")
+                return None
+
+            # Validate and create PricingData model
+            pricing_data = PricingData.from_dict(internal_pricing)
+
+            if verbose:
+                logger.info("pricing_data_loaded", model_count=len(pricing_data))
+
+            return pricing_data
+
+        except ValidationError as e:
+            if verbose:
+                logger.error("pricing_validation_failed", error=str(e))
+            return None
+        except Exception as e:
+            if verbose:
+                logger.error("pricing_load_failed", source="LiteLLM", error=str(e))
+            return None
+
+    @staticmethod
+    def validate_pricing_data(
+        pricing_data: Any, verbose: bool = True
+    ) -> PricingData | None:
+        """Validate pricing data using Pydantic models.
+
+        Args:
+            pricing_data: Pricing data to validate (dict or PricingData)
+            verbose: Whether to enable verbose logging
+
+        Returns:
+            Valid PricingData model or None if validation fails
+        """
+        try:
+            # If already a PricingData instance, return it
+            if isinstance(pricing_data, PricingData):
+                if verbose:
+                    logger.debug(
+                        "pricing_already_validated", model_count=len(pricing_data)
+                    )
+                return pricing_data
+
+            # If it's a dict, try to create PricingData from it
+            if isinstance(pricing_data, dict):
+                if not pricing_data:
+                    if verbose:
+                        logger.warning("pricing_data_empty")
+                    return None
+
+                # Try to create PricingData model
+                validated_data = PricingData.from_dict(pricing_data)
+
+                if verbose:
+                    logger.debug(
+                        "pricing_data_validated", model_count=len(validated_data)
+                    )
+
+                return validated_data
+
+            # Invalid type
+            if verbose:
+                logger.error(
+                    "pricing_data_invalid_type",
+                    actual_type=type(pricing_data).__name__,
+                    expected_types=["dict", "PricingData"],
+                )
+            return None
+
+        except ValidationError as e:
+            if verbose:
+                logger.error("pricing_validation_failed", error=str(e))
+            return None
+        except Exception as e:
+            if verbose:
+                logger.error("pricing_validation_unexpected_error", error=str(e))
+            return None
+
+    @staticmethod
+    def get_model_aliases() -> dict[str, str]:
+        """Get mapping of model aliases to canonical names.
+
+        Returns:
+            Dictionary mapping aliases to canonical model names
+        """
+        return PricingLoader.CLAUDE_MODEL_MAPPINGS.copy()
+
+    @staticmethod
+    def get_canonical_model_name(model_name: str) -> str:
+        """Get canonical model name for a given model name.
+
+        Args:
+            model_name: Model name (possibly an alias)
+
+        Returns:
+            Canonical model name
+        """
+        return PricingLoader.CLAUDE_MODEL_MAPPINGS.get(model_name, model_name)

ccproxy/pricing/models.py

@@ -0,0 +1,106 @@
+"""Pydantic models for pricing data validation and type safety."""
+
+from collections.abc import Iterator
+from decimal import Decimal
+from typing import Any
+
+from pydantic import BaseModel, Field, RootModel, field_validator
+
+
+class ModelPricing(BaseModel):
+    """Pricing information for a single Claude model.
+
+    All costs are in USD per 1 million tokens.
+    """
+
+    input: Decimal = Field(..., ge=0, description="Input token cost per 1M tokens")
+    output: Decimal = Field(..., ge=0, description="Output token cost per 1M tokens")
+    cache_read: Decimal = Field(
+        default=Decimal("0"), ge=0, description="Cache read cost per 1M tokens"
+    )
+    cache_write: Decimal = Field(
+        default=Decimal("0"), ge=0, description="Cache write cost per 1M tokens"
+    )
+
+    @field_validator("*", mode="before")
+    @classmethod
+    def convert_to_decimal(cls, v: Any) -> Decimal:
+        """Convert numeric values to Decimal for precision."""
+        if isinstance(v, int | float | str):
+            return Decimal(str(v))
+        if isinstance(v, Decimal):
+            return v
+        raise TypeError(f"Cannot convert {type(v)} to Decimal")
+
+    class Config:
+        """Pydantic configuration."""
+
+        arbitrary_types_allowed = True
+        json_encoders = {Decimal: lambda v: float(v)}
+
+
+class PricingData(RootModel[dict[str, ModelPricing]]):
+    """Complete pricing data for all Claude models.
+
+    This is a wrapper around a dictionary of model name to ModelPricing
+    that provides dict-like access while maintaining type safety.
+    """
+
+    def __iter__(self) -> Iterator[str]:  # type: ignore[override]
+        """Iterate over model names."""
+        return iter(self.root)
+
+    def __getitem__(self, model_name: str) -> ModelPricing:
+        """Get pricing for a specific model."""
+        return self.root[model_name]
+
+    def __contains__(self, model_name: str) -> bool:
+        """Check if model exists in pricing data."""
+        return model_name in self.root
+
+    def __len__(self) -> int:
+        """Get number of models in pricing data."""
+        return len(self.root)
+
+    def items(self) -> Iterator[tuple[str, ModelPricing]]:
+        """Get model name and pricing pairs."""
+        return iter(self.root.items())
+
+    def keys(self) -> Iterator[str]:
+        """Get model names."""
+        return iter(self.root.keys())
+
+    def values(self) -> Iterator[ModelPricing]:
+        """Get pricing objects."""
+        return iter(self.root.values())
+
+    def get(
+        self, model_name: str, default: ModelPricing | None = None
+    ) -> ModelPricing | None:
+        """Get pricing for a model with optional default."""
+        return self.root.get(model_name, default)
+
+    def model_names(self) -> list[str]:
+        """Get list of all model names."""
+        return list(self.root.keys())
+
+    def to_dict(self) -> dict[str, dict[str, Decimal]]:
+        """Convert to legacy dict format for backward compatibility."""
+        return {
+            model_name: {
+                "input": pricing.input,
+                "output": pricing.output,
+                "cache_read": pricing.cache_read,
+                "cache_write": pricing.cache_write,
+            }
+            for model_name, pricing in self.root.items()
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, dict[str, Any]]) -> "PricingData":
+        """Create PricingData from legacy dict format."""
+        models = {
+            model_name: ModelPricing(**pricing_dict)
+            for model_name, pricing_dict in data.items()
+        }
+        return cls(root=models)