model-forge-llm 0.2.0__py3-none-any.whl

modelforge/config.py

@@ -0,0 +1,211 @@
+"""Configuration management for ModelForge."""
+
+import json
+from pathlib import Path
+from typing import Any
+
+from .exceptions import ConfigurationError
+from .logging_config import get_logger
+
+logger = get_logger(__name__)
+
+# Configuration file paths
+GLOBAL_CONFIG_FILE = Path.home() / ".config" / "model-forge" / "config.json"
+LOCAL_CONFIG_FILE = Path.cwd() / ".model-forge" / "config.json"
+
+
+def get_config_path(local: bool = False) -> Path:
+    """
+    Determines which config file to use based on the local flag.
+
+    Args:
+        local: If True, returns path to local project config
+
+    Returns:
+        Path to the configuration file to use
+    """
+    if local:
+        return LOCAL_CONFIG_FILE
+
+    if LOCAL_CONFIG_FILE.exists():
+        return LOCAL_CONFIG_FILE
+
+    return GLOBAL_CONFIG_FILE
+
+
+def get_config() -> tuple[dict[str, Any], Path]:
+    """
+    Gets the configuration, with local taking precedence over global.
+
+    Returns:
+        Tuple of (config_data, config_path)
+    """
+    config_path = get_config_path()
+    return get_config_from_path(config_path)
+
+
+def get_config_from_path(path: Path) -> tuple[dict[str, Any], Path]:
+    """
+    Load configuration from a specific path.
+
+    Args:
+        path: Path to the configuration file
+
+    Returns:
+        Tuple of (config_data, config_path)
+
+    Raises:
+        ConfigurationError: If the file cannot be read or is invalid JSON
+    """
+    if not path.exists():
+        return {}, path
+
+    try:
+        with path.open() as f:
+            config_data = json.load(f)
+            logger.debug("Successfully loaded configuration from: %s", path)
+            return config_data, path
+    except json.JSONDecodeError as e:
+        logger.exception("Invalid JSON in configuration file %s", path)
+        raise ConfigurationError from e
+    except OSError as e:
+        logger.exception("Could not read configuration file %s", path)
+        raise ConfigurationError from e
+
+
+def save_config(config_data: dict[str, Any], local: bool = False) -> None:
+    """
+    Save configuration data to the appropriate config file.
+
+    Args:
+        config_data: The configuration data to save
+        local: If True, saves to local project config
+
+    Raises:
+        ConfigurationError: If the file cannot be written
+    """
+    config_path = get_config_path(local=local)
+    config_dir = config_path.parent
+
+    try:
+        config_dir.mkdir(parents=True, exist_ok=True)
+        with config_path.open("w") as f:
+            json.dump(config_data, f, indent=4)
+        logger.debug("Successfully saved configuration to: %s", config_path)
+    except OSError as e:
+        logger.exception("Could not save config file to %s", config_path)
+        raise ConfigurationError from e
+
+
+def set_current_model(provider: str, model: str, local: bool = False) -> bool:
+    """
+    Set the current model for the given provider.
+
+    Args:
+        provider: The provider name
+        model: The model alias
+        local: If True, modifies the local configuration
+
+    Returns:
+        True if successful, False otherwise
+    """
+    # When setting a model, we should read from the specific config file,
+    # not the merged one.
+    target_config_path = get_config_path(local=local)
+    config_data, _ = get_config_from_path(target_config_path)
+
+    # Check if provider and model exist in the configuration
+    providers = config_data.get("providers", {})
+    if provider not in providers:
+        scope = "local" if local else "global"
+        print(f"Error: Provider '{provider}' not found in {scope} configuration.")
+        print("Please add it using 'modelforge config add' first.")
+        return False
+
+    models = providers[provider].get("models", {})
+    if model not in models:
+        scope = "local" if local else "global"
+        print(
+            f"Error: Model '{model}' for provider '{provider}' not found "
+            f"in {scope} configuration."
+        )
+        print("Please add it using 'modelforge config add' first.")
+        return False
+
+    # Set the current model
+    config_data["current_model"] = {"provider": provider, "model": model}
+    save_config(config_data, local=local)
+    scope_msg = "local" if local else "global"
+    success_message = (
+        f"Successfully set '{model}' from provider '{provider}' as the current "
+        f"model in the {scope_msg} config."
+    )
+    logger.info(success_message)
+    print(success_message)
+    return True
+
+
+def get_current_model() -> dict[str, str] | None:
+    """
+    Get the currently selected model.
+
+    Returns:
+        Dictionary with 'provider' and 'model' keys, or None if not set
+    """
+    config_data, _ = get_config()
+    return config_data.get("current_model")
+
+
+def migrate_old_config() -> None:
+    """
+    Migrate configuration from the old location to the new global location.
+
+    Old location: ~/.config/model-forge/models.json
+    New location: ~/.config/model-forge/config.json
+    """
+    # Define old and new paths
+    old_config_file = Path.home() / ".config" / "model-forge" / "models.json"
+
+    if old_config_file.exists():
+        try:
+            # Read old configuration
+            with old_config_file.open() as f:
+                old_config_data = json.load(f)
+
+            # Check if new configuration already exists
+            if not GLOBAL_CONFIG_FILE.exists():
+                # Create new config directory
+                GLOBAL_CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+
+                # Write old data to new location
+                with GLOBAL_CONFIG_FILE.open("w") as f:
+                    json.dump(old_config_data, f, indent=4)
+
+                logger.info(
+                    "Migrated configuration from %s to %s",
+                    old_config_file,
+                    GLOBAL_CONFIG_FILE,
+                )
+                print(f"Configuration migrated from {old_config_file}")
+                print(f"  to: {GLOBAL_CONFIG_FILE}")
+                print("You can safely delete the old file if migration was successful.")
+
+            else:
+                logger.info(
+                    "Old configuration file found, but new global configuration "
+                    "already exists"
+                )
+                print(
+                    "Old configuration file found, but a new global configuration "
+                    "already exists."
+                )
+                print(f"  - Old: {old_config_file}")
+                print(f"  - New: {GLOBAL_CONFIG_FILE}")
+                print("Please manually review and merge if needed.")
+
+        except Exception as e:
+            logger.exception("Error during configuration migration")
+            print(f"Error during migration: {e}")
+    else:
+        print("No old configuration file found to migrate.")
+        print(f"Looking for: {old_config_file}")

modelforge/exceptions.py

@@ -0,0 +1,29 @@
+"""Custom exceptions for ModelForge."""
+
+
+class ModelForgeError(Exception):
+    """Base exception class for ModelForge."""
+
+
+class ConfigurationError(ModelForgeError):
+    """Raised when there's an issue with configuration."""
+
+
+class AuthenticationError(ModelForgeError):
+    """Raised when authentication fails."""
+
+
+class ProviderError(ModelForgeError):
+    """Raised when there's an issue with a provider."""
+
+
+class ModelNotFoundError(ModelForgeError):
+    """Raised when a requested model is not found."""
+
+
+class TokenExpiredError(AuthenticationError):
+    """Raised when an authentication token has expired."""
+
+
+class InvalidProviderError(ProviderError):
+    """Raised when an invalid provider is specified."""

modelforge/logging_config.py

@@ -0,0 +1,69 @@
+"""Logging configuration for ModelForge."""
+
+import logging
+import sys
+
+
+def setup_logging(
+    level: str = "INFO",
+    format_string: str | None = None,
+    filename: str | None = None,
+) -> logging.Logger:
+    """
+    Set up logging configuration for ModelForge.
+
+    Args:
+        level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+        format_string: Custom format string for log messages
+        filename: Optional log file path
+
+    Returns:
+        Configured logger instance
+    """
+    if format_string is None:
+        format_string = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+
+    # Create logger
+    logger = logging.getLogger("modelforge")
+    logger.setLevel(getattr(logging, level.upper()))
+
+    # Clear existing handlers
+    logger.handlers.clear()
+
+    # Create formatter
+    formatter = logging.Formatter(format_string)
+
+    # Console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(getattr(logging, level.upper()))
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+
+    # File handler (optional)
+    if filename:
+        file_handler = logging.FileHandler(filename)
+        file_handler.setLevel(getattr(logging, level.upper()))
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+
+    # Prevent propagation to root logger
+    logger.propagate = False
+
+    return logger
+
+
+def get_logger(name: str) -> logging.Logger:
+    """
+    Get a logger instance with the specified name.
+
+    Args:
+        name: Name of the logger (typically __name__)
+
+    Returns:
+        Logger instance
+    """
+    return logging.getLogger(f"modelforge.{name}")
+
+
+# Default logger setup
+default_logger = setup_logging()

modelforge/modelsdev.py

@@ -0,0 +1,364 @@
+"""Models.dev API integration for ModelForge."""
+
+import json
+import time
+from pathlib import Path
+from typing import Any
+
+import requests
+
+from .logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+class ModelsDevClient:
+    """Client for interacting with models.dev API."""
+
+    BASE_URL = "https://models.dev/api/v1"
+    CACHE_DIR = Path.home() / ".cache" / "model-forge" / "modelsdev"
+
+    # Cache TTL in seconds
+    CACHE_TTL = {
+        "providers": 24 * 3600,  # 24 hours
+        "models": 24 * 3600,  # 24 hours
+        "model_info": 7 * 24 * 3600,  # 7 days
+        "provider_config": 7 * 24 * 3600,  # 7 days
+    }
+
+    def __init__(self, api_key: str | None = None) -> None:
+        """Initialize the models.dev client.
+
+        Args:
+            api_key: Optional API key for authenticated requests
+        """
+        self.api_key = api_key
+        self.session = requests.Session()
+        if api_key:
+            self.session.headers.update({"Authorization": f"Bearer {api_key}"})
+
+        # Ensure cache directory exists
+        self.CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+    def _get_cache_path(self, endpoint: str, *args: str) -> Path:
+        """Get cache file path for an endpoint."""
+        filename = f"{endpoint}_{'_'.join(args)}.json" if args else f"{endpoint}.json"
+        return self.CACHE_DIR / filename
+
+    def _is_cache_valid(self, cache_path: Path, ttl: int) -> bool:
+        """Check if cached data is still valid."""
+        if not cache_path.exists():
+            return False
+
+        try:
+            cache_time = cache_path.stat().st_mtime
+            return time.time() - cache_time < ttl
+        except OSError:
+            return False
+
+    def _load_from_cache(self, cache_path: Path) -> dict[str, Any] | None:
+        """Load data from cache."""
+        try:
+            with cache_path.open() as f:
+                data = json.load(f)
+                if isinstance(data, dict):
+                    return data
+                if isinstance(data, list):
+                    return {"data": data}
+                return {"data": data}
+        except OSError:
+            logger.warning("Failed to read cache file: %s", cache_path)
+            return None
+        except json.JSONDecodeError as e:
+            logger.warning("Invalid JSON in cache file %s: %s", cache_path, e)
+            return None
+
+    def _save_to_cache(self, cache_path: Path, data: dict[str, Any]) -> None:
+        """Save data to cache."""
+        try:
+            with cache_path.open("w") as f:
+                json.dump(data, f, indent=2)
+        except OSError as e:
+            logger.warning("Failed to write cache file %s: %s", cache_path, e)
+
+    def get_providers(self, force_refresh: bool = False) -> list[dict[str, Any]]:
+        """Get list of supported providers from models.dev.
+
+        Args:
+            force_refresh: Force refresh from API even if cache is valid
+
+        Returns:
+            List of provider information dictionaries
+        """
+        cache_path = self._get_cache_path("providers")
+
+        if not force_refresh and self._is_cache_valid(
+            cache_path, self.CACHE_TTL["providers"]
+        ):
+            cached_data = self._load_from_cache(cache_path)
+            if cached_data and isinstance(cached_data, dict) and "data" in cached_data:
+                data = cached_data["data"]
+                if isinstance(data, list):
+                    return data
+                return [data]
+
+        try:
+            response = self.session.get(f"{self.BASE_URL}/providers")
+            response.raise_for_status()
+            providers_data = response.json()
+            providers: list[dict[str, Any]] = (
+                [providers_data]
+                if isinstance(providers_data, dict)
+                else providers_data
+                if isinstance(providers_data, list)
+                else [providers_data]
+            )
+        except requests.exceptions.ConnectionError:
+            logger.exception("Connection error while fetching providers")
+            cached_data = self._load_from_cache(cache_path)
+            if cached_data and isinstance(cached_data, dict) and "data" in cached_data:
+                logger.info("Using stale cached providers data")
+                return cached_data["data"]
+            raise
+        except requests.exceptions.HTTPError:
+            logger.exception("HTTP error while fetching providers")
+            cached_data = self._load_from_cache(cache_path)
+            if cached_data and isinstance(cached_data, dict) and "data" in cached_data:
+                logger.info("Using stale cached providers data")
+                return cached_data["data"]
+            raise
+        except requests.exceptions.Timeout:
+            logger.exception("Timeout while fetching providers")
+            cached_data = self._load_from_cache(cache_path)
+            if cached_data and isinstance(cached_data, dict) and "data" in cached_data:
+                logger.info("Using stale cached providers data")
+                return cached_data["data"]
+            raise
+        else:
+            self._save_to_cache(cache_path, {"data": providers})
+            return providers
+
+    def get_models(
+        self, provider: str | None = None, force_refresh: bool = False
+    ) -> list[dict[str, Any]]:
+        """Get list of models from models.dev.
+
+        Args:
+            provider: Optional provider filter
+            force_refresh: Force refresh from API even if cache is valid
+
+        Returns:
+            List of model information dictionaries
+        """
+        cache_path = self._get_cache_path("models", provider or "all")
+
+        if not force_refresh and self._is_cache_valid(
+            cache_path, self.CACHE_TTL["models"]
+        ):
+            cached_data = self._load_from_cache(cache_path)
+            if cached_data and isinstance(cached_data, dict) and "data" in cached_data:
+                data = cached_data["data"]
+                if isinstance(data, list):
+                    return data
+                return [data]
+
+        try:
+            url = f"{self.BASE_URL}/models"
+            params = {}
+            if provider:
+                params["provider"] = provider
+
+            response = self.session.get(url, params=params)
+            response.raise_for_status()
+            models_data = response.json()
+            models: list[dict[str, Any]] = (
+                models_data if isinstance(models_data, list) else [models_data]
+            )
+        except requests.exceptions.ConnectionError:
+            logger.exception("Connection error while fetching models")
+            cached_data = self._load_from_cache(cache_path)
+            if cached_data and isinstance(cached_data, dict) and "data" in cached_data:
+                logger.info("Using stale cached models data")
+                return cached_data["data"]
+            raise
+        except requests.exceptions.HTTPError:
+            logger.exception("HTTP error while fetching models")
+            cached_data = self._load_from_cache(cache_path)
+            if cached_data and isinstance(cached_data, dict) and "data" in cached_data:
+                logger.info("Using stale cached models data")
+                return cached_data["data"]
+            raise
+        except requests.exceptions.Timeout:
+            logger.exception("Timeout while fetching models")
+            cached_data = self._load_from_cache(cache_path)
+            if cached_data and isinstance(cached_data, dict) and "data" in cached_data:
+                logger.info("Using stale cached models data")
+                return cached_data["data"]
+            raise
+        else:
+            self._save_to_cache(cache_path, {"data": models})
+            return models
+
+    def get_model_info(
+        self, provider: str, model: str, force_refresh: bool = False
+    ) -> dict[str, Any]:
+        """Get detailed information about a specific model.
+
+        Args:
+            provider: Provider name
+            model: Model identifier
+            force_refresh: Force refresh from API even if cache is valid
+
+        Returns:
+            Model information dictionary
+        """
+        cache_path = self._get_cache_path("model_info", provider, model)
+
+        if not force_refresh and self._is_cache_valid(
+            cache_path, self.CACHE_TTL["model_info"]
+        ):
+            cached_data = self._load_from_cache(cache_path)
+            if cached_data and isinstance(cached_data, dict):
+                return cached_data
+
+        try:
+            url = f"{self.BASE_URL}/models/{provider}/{model}"
+            response = self.session.get(url)
+            response.raise_for_status()
+            model_info = response.json()
+            if not isinstance(model_info, dict):
+                model_info = {"model": model_info}
+        except requests.exceptions.ConnectionError:
+            logger.exception("Connection error while fetching model info")
+            cached_data = self._load_from_cache(cache_path)
+            if cached_data and isinstance(cached_data, dict):
+                logger.info("Using stale cached model info")
+                return cached_data
+            raise
+        except requests.exceptions.HTTPError:
+            logger.exception("HTTP error while fetching model info")
+            cached_data = self._load_from_cache(cache_path)
+            if cached_data and isinstance(cached_data, dict):
+                logger.info("Using stale cached model info")
+                return cached_data
+            raise
+        except requests.exceptions.Timeout:
+            logger.exception("Timeout while fetching model info")
+            cached_data = self._load_from_cache(cache_path)
+            if cached_data and isinstance(cached_data, dict):
+                logger.info("Using stale cached model info")
+                return cached_data
+            raise
+        else:
+            self._save_to_cache(cache_path, model_info)
+            return model_info
+
+    def get_provider_config(
+        self, provider: str, force_refresh: bool = False
+    ) -> dict[str, Any]:
+        """Get configuration template for a provider.
+
+        Args:
+            provider: Provider name
+            force_refresh: Force refresh from API even if cache is valid
+
+        Returns:
+            Provider configuration template
+        """
+        cache_path = self._get_cache_path("provider_config", provider)
+
+        if not force_refresh and self._is_cache_valid(
+            cache_path, self.CACHE_TTL["provider_config"]
+        ):
+            cached_data = self._load_from_cache(cache_path)
+            if cached_data and isinstance(cached_data, dict):
+                return cached_data
+
+        try:
+            url = f"{self.BASE_URL}/providers/{provider}/config"
+            response = self.session.get(url)
+            response.raise_for_status()
+            provider_config = response.json()
+            if not isinstance(provider_config, dict):
+                provider_config = {"config": provider_config}
+            return provider_config
+        except requests.exceptions.ConnectionError:
+            logger.exception("Connection error while fetching provider config")
+            cached_data = self._load_from_cache(cache_path)
+            if cached_data and isinstance(cached_data, dict):
+                logger.info("Using stale cached provider config")
+                return cached_data
+            raise
+        except requests.exceptions.HTTPError:
+            logger.exception("HTTP error while fetching provider config")
+            cached_data = self._load_from_cache(cache_path)
+            if cached_data and isinstance(cached_data, dict):
+                logger.info("Using stale cached provider config")
+                return cached_data
+            raise
+        except requests.exceptions.Timeout:
+            logger.exception("Timeout while fetching provider config")
+            cached_data = self._load_from_cache(cache_path)
+            if cached_data and isinstance(cached_data, dict):
+                logger.info("Using stale cached provider config")
+                return cached_data
+            raise
+        else:
+            self._save_to_cache(cache_path, provider_config)
+            return provider_config
+
+    def clear_cache(self) -> None:
+        """Clear all cached data."""
+        try:
+            for cache_file in self.CACHE_DIR.glob("*.json"):
+                cache_file.unlink()
+            logger.info("Cleared models.dev cache")
+        except OSError:
+            logger.exception("Failed to clear cache")
+
+    def search_models(
+        self,
+        query: str,
+        provider: str | None = None,
+        capabilities: list[str] | None = None,
+        max_price: float | None = None,
+        force_refresh: bool = False,
+    ) -> list[dict[str, Any]]:
+        """Search models based on criteria.
+
+        Args:
+            query: Search query string
+            provider: Optional provider filter
+            capabilities: Optional list of required capabilities
+            max_price: Optional maximum price filter
+            force_refresh: Force refresh from API
+
+        Returns:
+            List of matching models
+        """
+        models = self.get_models(provider=provider, force_refresh=force_refresh)
+
+        results = []
+        for model in models:
+            # Text search in name and description
+            model_text = (
+                f"{model.get('name', '')} {model.get('description', '')}".lower()
+            )
+            if query.lower() not in model_text:
+                continue
+
+            # Capabilities filter
+            if capabilities:
+                model_caps = set(model.get("capabilities", []))
+                if not set(capabilities).issubset(model_caps):
+                    continue
+
+            # Price filter
+            if max_price is not None:
+                price = model.get("pricing", {}).get("input_per_1k_tokens")
+                if price is not None and price > max_price:
+                    continue
+
+            results.append(model)
+
+        return results