config.py

"""Configuration management for api_optimizer."""

import os
import json
from pathlib import Path
from typing import Any, Dict, List, Optional, Union
from dataclasses import dataclass, field, asdict
from enum import Enum

try:
    import yaml
    YAML_AVAILABLE = True
except ImportError:
    YAML_AVAILABLE = False


@dataclass
class CacheConfig:
    """Cache configuration."""
    enabled: bool = True
    db_path: str = "cache.db"
    default_ttl: int = 3600
    similarity_threshold: float = 0.92
    max_entries: int = 10000
    semantic_search: bool = True
    embedding_provider: str = "simple"  # simple, openai
    embedding_model: str = "text-embedding-3-small"


@dataclass
class RouterConfig:
    """Router configuration."""
    enabled: bool = True
    default_model: str = "gpt-4o-mini"
    cost_optimization: bool = True
    max_cost_per_request: Optional[float] = None
    allowed_providers: List[str] = field(default_factory=lambda: ["openai", "anthropic"])


@dataclass
class MonitorConfig:
    """Monitor configuration."""
    enabled: bool = True
    db_path: str = "usage.db"
    daily_limit: Optional[float] = None
    weekly_limit: Optional[float] = None
    monthly_limit: Optional[float] = None
    per_request_limit: Optional[float] = None
    alert_threshold: float = 0.8
    hard_cap: bool = False


@dataclass
class OptimizerConfig:
    """Optimizer configuration."""
    enabled: bool = True
    aggressive: bool = False
    preserve_formatting: bool = True
    auto_optimize: bool = False
    min_savings_threshold: float = 0.05


@dataclass
class ProviderConfig:
    """API provider configuration."""
    name: str
    api_key: str = ""
    api_key_env: str = ""  # Environment variable name
    base_url: Optional[str] = None
    default_model: str = ""
    timeout: int = 60
    max_retries: int = 3

    def get_api_key(self) -> str:
        """Get API key from config or environment."""
        if self.api_key:
            return self.api_key
        if self.api_key_env:
            return os.environ.get(self.api_key_env, "")
        # Default environment variable names
        env_map = {
            "openai": "OPENAI_API_KEY",
            "anthropic": "ANTHROPIC_API_KEY",
        }
        return os.environ.get(env_map.get(self.name.lower(), ""), "")


@dataclass
class OptimizedClientConfig:
    """Main configuration for OptimizedClient."""
    cache: CacheConfig = field(default_factory=CacheConfig)
    router: RouterConfig = field(default_factory=RouterConfig)
    monitor: MonitorConfig = field(default_factory=MonitorConfig)
    optimizer: OptimizerConfig = field(default_factory=OptimizerConfig)
    providers: Dict[str, ProviderConfig] = field(default_factory=dict)

    # General settings
    default_provider: str = "openai"
    log_level: str = "INFO"
    data_dir: str = ".api_optimizer"

    def __post_init__(self):
        # Ensure data directory exists
        Path(self.data_dir).mkdir(parents=True, exist_ok=True)

        # Update paths to use data directory
        if not Path(self.cache.db_path).is_absolute():
            self.cache.db_path = str(Path(self.data_dir) / self.cache.db_path)
        if not Path(self.monitor.db_path).is_absolute():
            self.monitor.db_path = str(Path(self.data_dir) / self.monitor.db_path)

        # Set default providers if not configured
        if not self.providers:
            self.providers = {
                "openai": ProviderConfig(
                    name="openai",
                    api_key_env="OPENAI_API_KEY",
                    default_model="gpt-4o-mini"
                ),
                "anthropic": ProviderConfig(
                    name="anthropic",
                    api_key_env="ANTHROPIC_API_KEY",
                    default_model="claude-3-5-sonnet-20241022"
                )
            }


def load_config(config_path: Optional[str] = None) -> OptimizedClientConfig:
    """
    Load configuration from file or environment.

    Args:
        config_path: Path to config file (YAML or JSON)

    Returns:
        OptimizedClientConfig instance
    """
    config_data = {}

    # Try to find config file
    if config_path:
        config_file = Path(config_path)
    else:
        # Look for config in common locations
        search_paths = [
            Path("api_optimizer.yaml"),
            Path("api_optimizer.yml"),
            Path("api_optimizer.json"),
            Path(".api_optimizer.yaml"),
            Path(".api_optimizer.yml"),
            Path(".api_optimizer.json"),
            Path.home() / ".config" / "api_optimizer" / "config.yaml",
            Path.home() / ".config" / "api_optimizer" / "config.json",
        ]
        config_file = None
        for path in search_paths:
            if path.exists():
                config_file = path
                break

    # Load from file if found
    if config_file and config_file.exists():
        config_data = _load_file(config_file)

    # Override with environment variables
    config_data = _apply_env_overrides(config_data)

    # Build config object
    return _build_config(config_data)


def _load_file(path: Path) -> Dict[str, Any]:
    """Load configuration from file."""
    content = path.read_text()

    if path.suffix in (".yaml", ".yml"):
        if not YAML_AVAILABLE:
            raise ImportError("PyYAML required for YAML config files: pip install pyyaml")
        return yaml.safe_load(content) or {}
    elif path.suffix == ".json":
        return json.loads(content)
    else:
        # Try YAML first, then JSON
        if YAML_AVAILABLE:
            try:
                return yaml.safe_load(content) or {}
            except Exception:
                pass
        return json.loads(content)


def _apply_env_overrides(config: Dict[str, Any]) -> Dict[str, Any]:
    """Apply environment variable overrides."""
    env_mappings = {
        "API_OPTIMIZER_CACHE_ENABLED": ("cache", "enabled", _parse_bool),
        "API_OPTIMIZER_CACHE_TTL": ("cache", "default_ttl", int),
        "API_OPTIMIZER_CACHE_THRESHOLD": ("cache", "similarity_threshold", float),
        "API_OPTIMIZER_ROUTER_ENABLED": ("router", "enabled", _parse_bool),
        "API_OPTIMIZER_ROUTER_DEFAULT_MODEL": ("router", "default_model", str),
        "API_OPTIMIZER_ROUTER_COST_OPT": ("router", "cost_optimization", _parse_bool),
        "API_OPTIMIZER_MONITOR_ENABLED": ("monitor", "enabled", _parse_bool),
        "API_OPTIMIZER_MONITOR_DAILY_LIMIT": ("monitor", "daily_limit", float),
        "API_OPTIMIZER_MONITOR_WEEKLY_LIMIT": ("monitor", "weekly_limit", float),
        "API_OPTIMIZER_MONITOR_MONTHLY_LIMIT": ("monitor", "monthly_limit", float),
        "API_OPTIMIZER_OPTIMIZER_ENABLED": ("optimizer", "enabled", _parse_bool),
        "API_OPTIMIZER_OPTIMIZER_AGGRESSIVE": ("optimizer", "aggressive", _parse_bool),
        "API_OPTIMIZER_DEFAULT_PROVIDER": (None, "default_provider", str),
        "API_OPTIMIZER_DATA_DIR": (None, "data_dir", str),
        "API_OPTIMIZER_LOG_LEVEL": (None, "log_level", str),
    }

    for env_var, (section, key, converter) in env_mappings.items():
        value = os.environ.get(env_var)
        if value is not None:
            try:
                converted = converter(value)
                if section:
                    if section not in config:
                        config[section] = {}
                    config[section][key] = converted
                else:
                    config[key] = converted
            except (ValueError, TypeError):
                pass

    return config


def _parse_bool(value: str) -> bool:
    """Parse boolean from string."""
    return value.lower() in ("true", "1", "yes", "on")


def _build_config(data: Dict[str, Any]) -> OptimizedClientConfig:
    """Build config object from dictionary."""
    # Build sub-configs
    cache_data = data.get("cache", {})
    cache_config = CacheConfig(**{k: v for k, v in cache_data.items() if k in CacheConfig.__dataclass_fields__})

    router_data = data.get("router", {})
    router_config = RouterConfig(**{k: v for k, v in router_data.items() if k in RouterConfig.__dataclass_fields__})

    monitor_data = data.get("monitor", {})
    monitor_config = MonitorConfig(**{k: v for k, v in monitor_data.items() if k in MonitorConfig.__dataclass_fields__})

    optimizer_data = data.get("optimizer", {})
    optimizer_config = OptimizerConfig(**{k: v for k, v in optimizer_data.items() if k in OptimizerConfig.__dataclass_fields__})

    # Build provider configs
    providers = {}
    providers_data = data.get("providers", {})
    for name, pdata in providers_data.items():
        if isinstance(pdata, dict):
            providers[name] = ProviderConfig(name=name, **{k: v for k, v in pdata.items() if k in ProviderConfig.__dataclass_fields__ and k != "name"})

    # Build main config
    main_fields = {"default_provider", "log_level", "data_dir"}
    main_data = {k: v for k, v in data.items() if k in main_fields}

    return OptimizedClientConfig(
        cache=cache_config,
        router=router_config,
        monitor=monitor_config,
        optimizer=optimizer_config,
        providers=providers,
        **main_data
    )


def save_config(config: OptimizedClientConfig, path: str):
    """
    Save configuration to file.

    Args:
        config: Configuration to save
        path: Output file path
    """
    # Convert to dictionary
    data = {
        "cache": asdict(config.cache),
        "router": asdict(config.router),
        "monitor": asdict(config.monitor),
        "optimizer": asdict(config.optimizer),
        "providers": {name: asdict(p) for name, p in config.providers.items()},
        "default_provider": config.default_provider,
        "log_level": config.log_level,
        "data_dir": config.data_dir,
    }

    path = Path(path)

    if path.suffix in (".yaml", ".yml"):
        if not YAML_AVAILABLE:
            raise ImportError("PyYAML required for YAML config files")
        content = yaml.dump(data, default_flow_style=False, sort_keys=False)
    else:
        content = json.dumps(data, indent=2)

    path.write_text(content)


def create_default_config(path: str = "api_optimizer.yaml"):
    """Create a default configuration file."""
    config = OptimizedClientConfig()
    save_config(config, path)
    return path


# Alias for convenience
Config = OptimizedClientConfig