django-cfg 1.3.11__py3-none-any.whl → 1.4.0__py3-none-any.whl

django_cfg/modules/django_llm/llm/embeddings/__init__.py

@@ -0,0 +1,13 @@
+"""
+Embedding generation strategies for LLM client.
+
+Provides real and mock embedding implementations.
+"""
+
+from .openai_embedder import OpenAIEmbedder
+from .mock_embedder import MockEmbedder
+
+__all__ = [
+    'OpenAIEmbedder',
+    'MockEmbedder',
+]

django_cfg/modules/django_llm/llm/embeddings/mock_embedder.py

@@ -0,0 +1,106 @@
+"""
+Mock embedder for providers without embedding support.
+
+Generates mock embeddings using MD5 hash for OpenRouter and similar providers.
+"""
+
+import time
+import hashlib
+import logging
+from typing import Optional
+
+from ..costs import calculate_embedding_cost
+from ..models import EmbeddingResponse
+
+logger = logging.getLogger(__name__)
+
+
+class MockEmbedder:
+    """Generates mock embeddings for providers without embedding support."""
+
+    # Standard embedding dimension for ada-002 compatibility
+    EMBEDDING_DIMENSION = 1536
+
+    def __init__(self, models_cache=None):
+        """
+        Initialize mock embedder.
+
+        Args:
+            models_cache: Optional models cache for cost calculation
+        """
+        self.models_cache = models_cache
+
+    def generate(self, text: str, model: str) -> EmbeddingResponse:
+        """
+        Generate mock embedding using MD5 hash.
+
+        This is a workaround for OpenRouter which doesn't support embeddings.
+        The mock embedding is deterministic based on text content.
+
+        Args:
+            text: Text to generate embedding for
+            model: Model name (used for cost estimation)
+
+        Returns:
+            EmbeddingResponse with mock embedding vector and warning
+        """
+        start_time = time.time()
+
+        logger.warning(
+            "Using mock embedding generation. "
+            "OpenRouter doesn't support embedding models."
+        )
+
+        # Create mock embedding from text hash
+        mock_embedding = self._create_mock_vector(text)
+
+        # Estimate tokens and cost
+        tokens_used = len(text.split())  # Rough estimate
+        cost = calculate_embedding_cost(tokens_used, model, self.models_cache)
+
+        response_time = time.time() - start_time
+
+        logger.debug(
+            f"Generated mock embedding: {tokens_used} tokens (estimated), "
+            f"${cost:.6f}, {response_time:.2f}s"
+        )
+
+        return EmbeddingResponse(
+            embedding=mock_embedding,
+            tokens=tokens_used,
+            cost=cost,
+            model=model,
+            text_length=len(text),
+            dimension=len(mock_embedding),
+            response_time=response_time,
+            warning="Mock embedding - OpenRouter doesn't support embedding models"
+        )
+
+    def _create_mock_vector(self, text: str) -> list:
+        """
+        Create mock embedding vector from text hash.
+
+        Uses MD5 hash to create a deterministic vector that's consistent
+        for the same text but different for different texts.
+
+        Args:
+            text: Input text
+
+        Returns:
+            List of floats representing the mock embedding
+        """
+        # Generate MD5 hash of text
+        text_hash = hashlib.md5(text.encode()).hexdigest()
+
+        # Convert hex pairs to normalized floats (0.0 - 1.0)
+        mock_embedding = [
+            float(int(text_hash[i:i+2], 16)) / 255.0
+            for i in range(0, min(32, len(text_hash)), 2)
+        ]
+
+        # Pad to standard embedding size
+        while len(mock_embedding) < self.EMBEDDING_DIMENSION:
+            mock_embedding.append(0.0)
+
+        # Truncate to exact dimension
+        return mock_embedding[:self.EMBEDDING_DIMENSION]

django_cfg/modules/django_llm/llm/embeddings/openai_embedder.py

@@ -0,0 +1,79 @@
+"""
+OpenAI embedder for real embedding generation.
+
+Uses OpenAI Embeddings API to generate high-quality embeddings.
+"""
+
+import time
+import logging
+from typing import Optional
+
+from ..costs import calculate_embedding_cost
+from ..models import EmbeddingResponse
+
+logger = logging.getLogger(__name__)
+
+
+class OpenAIEmbedder:
+    """Generates real embeddings using OpenAI API."""
+
+    def __init__(self, models_cache=None):
+        """
+        Initialize OpenAI embedder.
+
+        Args:
+            models_cache: Optional models cache for cost calculation
+        """
+        self.models_cache = models_cache
+
+    def generate(self, client, text: str, model: str) -> EmbeddingResponse:
+        """
+        Generate real embedding via OpenAI API.
+
+        Args:
+            client: OpenAI client instance
+            text: Text to generate embedding for
+            model: Embedding model to use
+
+        Returns:
+            EmbeddingResponse with embedding vector and metadata
+        """
+        start_time = time.time()
+
+        # Remove provider prefix if present
+        api_model = model
+        if model.startswith("openai/"):
+            api_model = model.replace("openai/", "")
+
+        logger.debug(f"Generating embedding with model: {api_model}")
+
+        # Make API call
+        response = client.embeddings.create(
+            input=text,
+            model=api_model
+        )
+
+        # Extract embedding data
+        embedding_data = response.data[0]
+        embedding_vector = embedding_data.embedding
+
+        # Calculate tokens and cost
+        tokens_used = response.usage.total_tokens
+        cost = calculate_embedding_cost(tokens_used, model, self.models_cache)
+
+        response_time = time.time() - start_time
+
+        logger.debug(
+            f"Generated embedding: {tokens_used} tokens, "
+            f"${cost:.6f}, {response_time:.2f}s"
+        )
+
+        return EmbeddingResponse(
+            embedding=embedding_vector,
+            tokens=tokens_used,
+            cost=cost,
+            model=model,
+            text_length=len(text),
+            dimension=len(embedding_vector),
+            response_time=response_time
+        )

django_cfg/modules/django_llm/llm/models_api/__init__.py

@@ -0,0 +1,9 @@
+"""
+Models API for LLM client.
+
+Provides query interface to models cache.
+"""
+
+from .models_query import ModelsQueryAPI
+
+__all__ = ['ModelsQueryAPI']

django_cfg/modules/django_llm/llm/models_api/models_query.py

@@ -0,0 +1,163 @@
+"""
+Models query API for LLM client.
+
+Provides simplified interface to query models cache.
+"""
+
+import logging
+from typing import Dict, List, Optional, Any
+
+from ..models_cache import ModelsCache, ModelInfo
+
+logger = logging.getLogger(__name__)
+
+
+class ModelsQueryAPI:
+    """Provides query interface to models cache."""
+
+    def __init__(self, models_cache: Optional[ModelsCache] = None):
+        """
+        Initialize models query API.
+
+        Args:
+            models_cache: Optional models cache instance
+        """
+        self.models_cache = models_cache
+
+    async def fetch_models(self, force_refresh: bool = False) -> Dict[str, ModelInfo]:
+        """
+        Fetch available models with pricing information.
+
+        Args:
+            force_refresh: Force refresh even if cache is valid
+
+        Returns:
+            Dictionary of model_id -> ModelInfo
+        """
+        if not self.models_cache:
+            logger.warning("Models cache not available for this provider")
+            return {}
+
+        return await self.models_cache.fetch_models(force_refresh=force_refresh)
+
+    def get_model_info(self, model_id: str) -> Optional[ModelInfo]:
+        """
+        Get information about a specific model.
+
+        Args:
+            model_id: Model identifier
+
+        Returns:
+            ModelInfo or None if not found
+        """
+        if not self.models_cache:
+            return None
+
+        return self.models_cache.get_model(model_id)
+
+    def get_models_by_price(
+        self,
+        min_price: float = 0.0,
+        max_price: float = float('inf')
+    ) -> List[ModelInfo]:
+        """
+        Get models within a price range.
+
+        Args:
+            min_price: Minimum price
+            max_price: Maximum price
+
+        Returns:
+            List of ModelInfo objects
+        """
+        if not self.models_cache:
+            return []
+
+        return self.models_cache.get_models_by_price_range(min_price, max_price)
+
+    def get_free_models(self) -> List[ModelInfo]:
+        """
+        Get all free models.
+
+        Returns:
+            List of free ModelInfo objects
+        """
+        if not self.models_cache:
+            return []
+
+        return self.models_cache.get_free_models()
+
+    def get_budget_models(self, max_price: float = 1.0) -> List[ModelInfo]:
+        """
+        Get budget-friendly models.
+
+        Args:
+            max_price: Maximum price threshold
+
+        Returns:
+            List of budget ModelInfo objects
+        """
+        if not self.models_cache:
+            return []
+
+        return self.models_cache.get_budget_models(max_price)
+
+    def get_premium_models(self, min_price: float = 10.0) -> List[ModelInfo]:
+        """
+        Get premium models.
+
+        Args:
+            min_price: Minimum price threshold
+
+        Returns:
+            List of premium ModelInfo objects
+        """
+        if not self.models_cache:
+            return []
+
+        return self.models_cache.get_premium_models(min_price)
+
+    def search_models(self, query: str) -> List[ModelInfo]:
+        """
+        Search models by name, description, or tags.
+
+        Args:
+            query: Search query string
+
+        Returns:
+            List of matching ModelInfo objects
+        """
+        if not self.models_cache:
+            return []
+
+        return self.models_cache.search_models(query)
+
+    def get_models_summary(self) -> Dict[str, Any]:
+        """
+        Get summary of available models.
+
+        Returns:
+            Dictionary with models summary statistics
+        """
+        if not self.models_cache:
+            return {"error": "Models cache not available for this provider"}
+
+        return self.models_cache.get_models_summary()
+
+    def get_models_cache_info(self) -> Dict[str, Any]:
+        """
+        Get models cache information.
+
+        Returns:
+            Dictionary with cache information
+        """
+        if not self.models_cache:
+            return {"error": "Models cache not available for this provider"}
+
+        return self.models_cache.get_cache_info()
+
+    def clear_models_cache(self):
+        """Clear the models cache."""
+        if self.models_cache:
+            self.models_cache.clear_cache()
+            logger.info("Models cache cleared")

django_cfg/modules/django_llm/llm/providers/__init__.py

@@ -0,0 +1,15 @@
+"""
+Provider management for LLM client.
+
+Handles initialization, configuration, and selection of LLM providers.
+"""
+
+from .config_builder import ConfigBuilder
+from .provider_manager import ProviderManager
+from .provider_selector import ProviderSelector
+
+__all__ = [
+    'ConfigBuilder',
+    'ProviderManager',
+    'ProviderSelector',
+]

django_cfg/modules/django_llm/llm/providers/config_builder.py

@@ -0,0 +1,103 @@
+"""
+Configuration builder for LLM providers.
+
+Builds provider-specific configurations and headers.
+"""
+
+import logging
+from typing import Dict, Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class ConfigBuilder:
+    """Builds configuration for LLM providers."""
+
+    @staticmethod
+    def get_openrouter_headers(django_config: Optional[Any] = None) -> Dict[str, str]:
+        """
+        Build headers for OpenRouter API.
+
+        Args:
+            django_config: Django configuration object
+
+        Returns:
+            Dictionary of headers for OpenRouter
+        """
+        headers = {}
+
+        if django_config:
+            try:
+                site_url = getattr(django_config, 'site_url', 'http://localhost:8000')
+                project_name = getattr(django_config, 'project_name', 'Django CFG')
+                headers.update({
+                    "HTTP-Referer": site_url,
+                    "X-Title": project_name
+                })
+            except Exception as e:
+                logger.warning(f"Failed to extract config for OpenRouter headers: {e}")
+
+        return headers
+
+    @staticmethod
+    def get_provider_config(
+        provider: str,
+        django_config: Optional[Any] = None
+    ) -> Dict[str, Any]:
+        """
+        Get full provider configuration.
+
+        Args:
+            provider: Provider name ("openai" or "openrouter")
+            django_config: Django configuration object
+
+        Returns:
+            Provider configuration dictionary
+
+        Raises:
+            ValueError: If provider is not supported
+        """
+        base_configs = {
+            "openrouter": {
+                "base_url": "https://openrouter.ai/api/v1",
+                "headers": ConfigBuilder.get_openrouter_headers(django_config)
+            },
+            "openai": {
+                "base_url": "https://api.openai.com/v1",
+                "headers": {}
+            }
+        }
+
+        if provider not in base_configs:
+            raise ValueError(f"Unsupported provider: {provider}")
+
+        config = base_configs[provider].copy()
+
+        # Add custom headers from LLM config if available
+        if django_config:
+            try:
+                if hasattr(django_config, 'llm') and django_config.llm:
+                    llm_config = django_config.llm
+                    if hasattr(llm_config, 'custom_headers'):
+                        config["headers"].update(llm_config.custom_headers)
+            except Exception as e:
+                logger.warning(f"Failed to add custom headers: {e}")
+
+        return config
+
+    @staticmethod
+    def get_default_model(provider: str) -> str:
+        """
+        Get default model for provider.
+
+        Args:
+            provider: Provider name
+
+        Returns:
+            Default model ID
+        """
+        default_models = {
+            "openrouter": "openai/gpt-4o-mini",
+            "openai": "gpt-4o-mini"
+        }
+        return default_models.get(provider, "gpt-4o-mini")

django_cfg/modules/django_llm/llm/providers/provider_manager.py

@@ -0,0 +1,148 @@
+"""
+Provider manager for LLM client.
+
+Manages initialization and access to LLM provider clients.
+"""
+
+import logging
+from typing import Dict, Optional, Any
+from openai import OpenAI
+
+from .config_builder import ConfigBuilder
+
+logger = logging.getLogger(__name__)
+
+
+class ProviderManager:
+    """Manages LLM provider clients and API keys."""
+
+    def __init__(
+        self,
+        apikey_openrouter: Optional[str] = None,
+        apikey_openai: Optional[str] = None,
+        preferred_provider: Optional[str] = None,
+        django_config: Optional[Any] = None
+    ):
+        """
+        Initialize provider manager.
+
+        Args:
+            apikey_openrouter: OpenRouter API key
+            apikey_openai: OpenAI API key
+            preferred_provider: Preferred provider ("openai" or "openrouter")
+            django_config: Django configuration object
+        """
+        self.apikey_openrouter = apikey_openrouter
+        self.apikey_openai = apikey_openai
+        self.preferred_provider = preferred_provider
+        self.django_config = django_config
+
+        # Initialize clients dictionary
+        self.clients: Dict[str, OpenAI] = {}
+
+        # Initialize clients for available providers
+        self._init_openrouter_client()
+        self._init_openai_client()
+
+        # Determine primary provider
+        self.primary_provider = self._determine_primary_provider()
+
+        # Get primary client
+        self.primary_client = self.clients[self.primary_provider]
+
+        logger.info(f"Initialized ProviderManager with primary provider: {self.primary_provider}")
+
+    def _init_openrouter_client(self):
+        """Initialize OpenRouter client if API key is available."""
+        if self.apikey_openrouter:
+            try:
+                headers = ConfigBuilder.get_openrouter_headers(self.django_config)
+                self.clients["openrouter"] = OpenAI(
+                    base_url="https://openrouter.ai/api/v1",
+                    api_key=self.apikey_openrouter,
+                    default_headers=headers
+                )
+                logger.info("OpenRouter client initialized")
+            except Exception as e:
+                logger.error(f"Failed to initialize OpenRouter client: {e}")
+
+    def _init_openai_client(self):
+        """Initialize OpenAI client if API key is available."""
+        if self.apikey_openai:
+            try:
+                self.clients["openai"] = OpenAI(api_key=self.apikey_openai)
+                logger.info("OpenAI client initialized")
+            except Exception as e:
+                logger.error(f"Failed to initialize OpenAI client: {e}")
+
+    def _determine_primary_provider(self) -> str:
+        """
+        Determine primary provider based on preference and available keys.
+
+        Returns:
+            Primary provider name
+
+        Raises:
+            ValueError: If no provider is available
+        """
+        # If preferred provider is explicitly set and available, use it
+        if self.preferred_provider:
+            if self.preferred_provider == "openai" and "openai" in self.clients:
+                return "openai"
+            elif self.preferred_provider == "openrouter" and "openrouter" in self.clients:
+                return "openrouter"
+            else:
+                logger.warning(
+                    f"Preferred provider '{self.preferred_provider}' not available, "
+                    f"falling back to auto-detection"
+                )
+
+        # Auto-detection: prefer OpenAI for better compatibility
+        if "openai" in self.clients:
+            return "openai"
+        elif "openrouter" in self.clients:
+            return "openrouter"
+        else:
+            raise ValueError(
+                "At least one API key (openrouter or openai) must be provided"
+            )
+
+    def get_client(self, provider: Optional[str] = None) -> OpenAI:
+        """
+        Get client for specific provider or primary.
+
+        Args:
+            provider: Provider name (None for primary)
+
+        Returns:
+            OpenAI client instance
+
+        Raises:
+            ValueError: If provider is not available
+        """
+        if provider:
+            if provider not in self.clients:
+                raise ValueError(f"Provider '{provider}' not available")
+            return self.clients[provider]
+        return self.primary_client
+
+    def has_provider(self, provider: str) -> bool:
+        """
+        Check if provider is available.
+
+        Args:
+            provider: Provider name
+
+        Returns:
+            True if provider is available
+        """
+        return provider in self.clients
+
+    def get_available_providers(self) -> list:
+        """
+        Get list of available providers.
+
+        Returns:
+            List of provider names
+        """
+        return list(self.clients.keys())

django_cfg/modules/django_llm/llm/providers/provider_selector.py

@@ -0,0 +1,60 @@
+"""
+Provider selector for LLM client.
+
+Selects optimal provider for specific tasks.
+"""
+
+import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .provider_manager import ProviderManager
+
+logger = logging.getLogger(__name__)
+
+
+class ProviderSelector:
+    """Selects optimal provider for specific tasks."""
+
+    def __init__(self, provider_manager: 'ProviderManager'):
+        """
+        Initialize provider selector.
+
+        Args:
+            provider_manager: ProviderManager instance
+        """
+        self.provider_manager = provider_manager
+
+    def get_provider_for_task(self, task: str = "chat") -> str:
+        """
+        Get the best provider for a specific task.
+
+        Args:
+            task: Task type ("chat", "embedding", "completion")
+
+        Returns:
+            Provider name for the task
+        """
+        # For embeddings, always prefer OpenAI if available
+        # OpenRouter doesn't have proper embedding support
+        if task == "embedding" and self.provider_manager.has_provider("openai"):
+            logger.debug("Selecting OpenAI for embedding task")
+            return "openai"
+
+        # For other tasks, use primary provider
+        provider = self.provider_manager.primary_provider
+        logger.debug(f"Selecting {provider} for {task} task")
+        return provider
+
+    def should_use_mock_embedding(self, provider: str) -> bool:
+        """
+        Determine if mock embedding should be used for provider.
+
+        Args:
+            provider: Provider name
+
+        Returns:
+            True if mock embedding should be used
+        """
+        # OpenRouter doesn't support real embeddings
+        return provider == "openrouter"