ccproxy-api 0.1.6__py3-none-any.whl → 0.2.0__py3-none-any.whl

ccproxy/observability/storage/models.py

@@ -1,70 +0,0 @@
-"""
-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 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)
-    num_turns: int = Field(default=0)  # number of conversation turns
-
-    # Session context metadata
-    session_type: str = Field(default="")  # "session_pool" or "direct"
-    session_status: str = Field(default="")  # active, idle, connecting, etc.
-    session_age_seconds: float = Field(default=0.0)  # how long session has been alive
-    session_message_count: int = Field(default=0)  # number of messages in session
-    session_client_id: str = Field(default="")  # unique session client identifier
-    session_pool_enabled: bool = Field(
-        default=False
-    )  # whether session pooling is enabled
-    session_idle_seconds: float = Field(default=0.0)  # how long since last activity
-    session_error_count: int = Field(default=0)  # number of errors in this session
-    session_is_new: bool = Field(
-        default=True
-    )  # whether this is a newly created session
-
-    class Config:
-        """SQLModel configuration."""
-
-        # Enable automatic conversion from dict
-        from_attributes = True
-        # Use enum values
-        use_enum_values = True

ccproxy/observability/streaming_response.py

@@ -1,107 +0,0 @@
-"""FastAPI StreamingResponse with automatic access logging on completion.
-
-This module provides a reusable StreamingResponseWithLogging class that wraps
-any async generator and handles access logging when the stream completes,
-eliminating code duplication between different streaming endpoints.
-"""
-
-from __future__ import annotations
-
-from collections.abc import AsyncGenerator, AsyncIterator
-from typing import TYPE_CHECKING, Any
-
-import structlog
-from fastapi.responses import StreamingResponse
-
-from ccproxy.observability.access_logger import log_request_access
-
-
-if TYPE_CHECKING:
-    from ccproxy.observability.context import RequestContext
-    from ccproxy.observability.metrics import PrometheusMetrics
-
-logger = structlog.get_logger(__name__)
-
-
-class StreamingResponseWithLogging(StreamingResponse):
-    """FastAPI StreamingResponse that triggers access logging on completion.
-
-    This class wraps a streaming response generator to automatically trigger
-    access logging when the stream completes (either successfully or with an error).
-    This eliminates the need for manual access logging in individual stream processors.
-    """
-
-    def __init__(
-        self,
-        content: AsyncGenerator[bytes, None] | AsyncIterator[bytes],
-        request_context: RequestContext,
-        metrics: PrometheusMetrics | None = None,
-        status_code: int = 200,
-        **kwargs: Any,
-    ) -> None:
-        """Initialize streaming response with logging capability.
-
-        Args:
-            content: The async generator producing streaming content
-            request_context: The request context for access logging
-            metrics: Optional PrometheusMetrics instance for recording metrics
-            status_code: HTTP status code for the response
-            **kwargs: Additional arguments passed to StreamingResponse
-        """
-        # Wrap the content generator to add logging
-        logged_content = self._wrap_with_logging(
-            content, request_context, metrics, status_code
-        )
-        super().__init__(logged_content, status_code=status_code, **kwargs)
-
-    async def _wrap_with_logging(
-        self,
-        content: AsyncGenerator[bytes, None] | AsyncIterator[bytes],
-        context: RequestContext,
-        metrics: PrometheusMetrics | None,
-        status_code: int,
-    ) -> AsyncGenerator[bytes, None]:
-        """Wrap content generator with access logging on completion.
-
-        Args:
-            content: The original content generator
-            context: Request context for logging
-            metrics: Optional metrics instance
-            status_code: HTTP status code
-
-        Yields:
-            bytes: Content chunks from the original generator
-        """
-        try:
-            # Stream all content from the original generator
-            async for chunk in content:
-                yield chunk
-        except GeneratorExit:
-            # Client disconnected - log this and re-raise to propagate to underlying generators
-            logger.info(
-                "streaming_response_client_disconnected",
-                request_id=context.request_id,
-                message="Client disconnected from streaming response, propagating GeneratorExit",
-            )
-            # CRITICAL: Re-raise GeneratorExit to propagate disconnect to create_listener()
-            raise
-        finally:
-            # Log access when stream completes (success or error)
-            try:
-                # Add streaming completion event type to context
-                context.add_metadata(event_type="streaming_complete")
-
-                # Check if status_code was updated in context metadata (e.g., due to error)
-                final_status_code = context.metadata.get("status_code", status_code)
-
-                await log_request_access(
-                    context=context,
-                    status_code=final_status_code,
-                    metrics=metrics,
-                )
-            except Exception as e:
-                logger.warning(
-                    "streaming_access_log_failed",
-                    error=str(e),
-                    request_id=context.request_id,
-                )

ccproxy/pricing/__init__.py

@@ -1,19 +0,0 @@
-"""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/loader.py

@@ -1,251 +0,0 @@
-"""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 ccproxy.utils.model_mapping import get_claude_aliases_mapping, map_model_to_claude
-
-from .models import PricingData
-
-
-logger = get_logger(__name__)
-
-
-class PricingLoader:
-    """Loads and converts pricing data from LiteLLM format to internal format."""
-
-    @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 = map_model_to_claude(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 get_claude_aliases_mapping()
-
-    @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 map_model_to_claude(model_name)