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

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

@@ -0,0 +1,15 @@
+"""
+Request handling for LLM client.
+
+Handles chat completion and embedding requests with caching.
+"""
+
+from .cache_manager import RequestCacheManager
+from .chat_handler import ChatRequestHandler
+from .embedding_handler import EmbeddingRequestHandler
+
+__all__ = [
+    'RequestCacheManager',
+    'ChatRequestHandler',
+    'EmbeddingRequestHandler',
+]

django_cfg/modules/django_llm/llm/requests/cache_manager.py

@@ -0,0 +1,170 @@
+"""
+Cache manager for LLM requests.
+
+Manages caching of chat and embedding requests.
+"""
+
+import logging
+from typing import Optional, Dict, Any, List
+from pathlib import Path
+
+from ..cache import LLMCache
+from ..models import ChatCompletionResponse, EmbeddingResponse
+
+logger = logging.getLogger(__name__)
+
+
+class RequestCacheManager:
+    """Manages caching for LLM requests."""
+
+    def __init__(
+        self,
+        cache_dir: Optional[Path] = None,
+        cache_ttl: int = 3600,
+        max_cache_size: int = 1000
+    ):
+        """
+        Initialize cache manager.
+
+        Args:
+            cache_dir: Cache directory path
+            cache_ttl: Cache TTL in seconds
+            max_cache_size: Maximum cache size
+        """
+        self.cache = LLMCache(
+            cache_dir=cache_dir,
+            ttl=cache_ttl,
+            max_size=max_cache_size
+        )
+
+    def get_cached_chat(
+        self,
+        messages: List[Dict[str, str]],
+        model: str,
+        max_tokens: Optional[int] = None,
+        temperature: Optional[float] = None,
+        response_format: Optional[str] = None,
+        **kwargs
+    ) -> Optional[ChatCompletionResponse]:
+        """
+        Get cached chat completion response.
+
+        Args:
+            messages: Chat messages
+            model: Model used
+            max_tokens: Max tokens
+            temperature: Temperature
+            response_format: Response format
+            **kwargs: Additional parameters
+
+        Returns:
+            Cached response or None
+        """
+        request_hash = self.cache.generate_request_hash(
+            messages=messages,
+            model=model,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            response_format=response_format,
+            **kwargs
+        )
+
+        cached_response = self.cache.get_response(request_hash)
+        if cached_response:
+            logger.debug("Cache hit for chat completion")
+            return ChatCompletionResponse(**cached_response)
+
+        return None
+
+    def cache_chat_response(
+        self,
+        response: ChatCompletionResponse,
+        messages: List[Dict[str, str]],
+        model: str,
+        max_tokens: Optional[int] = None,
+        temperature: Optional[float] = None,
+        response_format: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        Cache chat completion response.
+
+        Args:
+            response: Response to cache
+            messages: Chat messages
+            model: Model used
+            max_tokens: Max tokens
+            temperature: Temperature
+            response_format: Response format
+            **kwargs: Additional parameters
+        """
+        request_hash = self.cache.generate_request_hash(
+            messages=messages,
+            model=model,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            response_format=response_format,
+            **kwargs
+        )
+
+        self.cache.set_response(request_hash, response.model_dump(), model)
+        logger.debug("Cached chat completion response")
+
+    def get_cached_embedding(
+        self,
+        text: str,
+        model: str
+    ) -> Optional[EmbeddingResponse]:
+        """
+        Get cached embedding response.
+
+        Args:
+            text: Input text
+            model: Model used
+
+        Returns:
+            Cached response or None
+        """
+        request_hash = self.cache.generate_request_hash(
+            messages=[{"role": "user", "content": text}],
+            model=model,
+            task="embedding"
+        )
+
+        cached_response = self.cache.get_response(request_hash)
+        if cached_response:
+            logger.debug("Cache hit for embedding generation")
+            return EmbeddingResponse(**cached_response)
+
+        return None
+
+    def cache_embedding_response(
+        self,
+        response: EmbeddingResponse,
+        text: str,
+        model: str
+    ):
+        """
+        Cache embedding response.
+
+        Args:
+            response: Response to cache
+            text: Input text
+            model: Model used
+        """
+        request_hash = self.cache.generate_request_hash(
+            messages=[{"role": "user", "content": text}],
+            model=model,
+            task="embedding"
+        )
+
+        self.cache.set_response(request_hash, response.model_dump(), model)
+        logger.debug("Cached embedding response")
+
+    def get_cache_info(self) -> Dict[str, Any]:
+        """Get cache information."""
+        return self.cache.get_cache_info()
+
+    def clear_cache(self):
+        """Clear the cache."""
+        self.cache.clear_cache()

django_cfg/modules/django_llm/llm/requests/chat_handler.py

@@ -0,0 +1,199 @@
+"""
+Chat request handler for LLM client.
+
+Handles chat completion requests with caching and response building.
+"""
+
+import time
+import logging
+from typing import List, Dict, Optional, TYPE_CHECKING
+
+from ..models import ChatCompletionResponse
+from ..providers import ConfigBuilder
+
+if TYPE_CHECKING:
+    from ..providers import ProviderManager
+    from ..responses import ResponseBuilder
+    from ..stats import StatsManager
+    from .cache_manager import RequestCacheManager
+
+logger = logging.getLogger(__name__)
+
+
+class ChatRequestHandler:
+    """Handles chat completion requests with caching."""
+
+    def __init__(
+        self,
+        provider_manager: 'ProviderManager',
+        cache_manager: 'RequestCacheManager',
+        stats_manager: 'StatsManager',
+        response_builder: 'ResponseBuilder',
+        tokenizer
+    ):
+        """
+        Initialize chat request handler.
+
+        Args:
+            provider_manager: Provider manager instance
+            cache_manager: Cache manager instance
+            stats_manager: Stats manager instance
+            response_builder: Response builder instance
+            tokenizer: Tokenizer instance
+        """
+        self.provider_manager = provider_manager
+        self.cache_manager = cache_manager
+        self.stats_manager = stats_manager
+        self.response_builder = response_builder
+        self.tokenizer = tokenizer
+
+    def chat_completion(
+        self,
+        messages: List[Dict[str, str]],
+        model: Optional[str] = None,
+        max_tokens: Optional[int] = None,
+        temperature: Optional[float] = None,
+        response_format: Optional[str] = None,
+        **kwargs
+    ) -> ChatCompletionResponse:
+        """
+        Execute chat completion with caching.
+
+        Args:
+            messages: List of chat messages
+            model: Model to use
+            max_tokens: Maximum tokens
+            temperature: Temperature for generation
+            response_format: Response format (e.g., "json")
+            **kwargs: Additional parameters
+
+        Returns:
+            Chat completion response
+
+        Raises:
+            RuntimeError: If client is not initialized or request fails
+        """
+        # Get client and provider
+        client = self.provider_manager.primary_client
+        provider = self.provider_manager.primary_provider
+
+        if not client:
+            raise RuntimeError("OpenAI client not initialized")
+
+        # Use default model if needed
+        if model is None:
+            model = ConfigBuilder.get_default_model(provider)
+
+        # Prepare API model (remove prefix for OpenAI)
+        api_model = self._prepare_api_model(model, provider)
+
+        # Check cache
+        cached_response = self.cache_manager.get_cached_chat(
+            messages, model, max_tokens, temperature, response_format, **kwargs
+        )
+        if cached_response:
+            self.stats_manager.record_cache_hit()
+            return cached_response
+
+        self.stats_manager.record_cache_miss()
+        self.stats_manager.record_request()
+
+        # Estimate tokens
+        estimated_tokens = self.tokenizer.count_messages_tokens(messages, model)
+        logger.debug(f"Estimated input tokens: {estimated_tokens}")
+
+        # Make API call
+        start_time = time.time()
+        try:
+            api_response = self._make_api_call(
+                client, api_model, messages, max_tokens, temperature, response_format, **kwargs
+            )
+            processing_time = time.time() - start_time
+
+            # Build response object
+            completion_response = self.response_builder.build_chat_response(
+                api_response, model, provider, response_format, processing_time
+            )
+
+            # Cache response
+            self.cache_manager.cache_chat_response(
+                completion_response, messages, model, max_tokens, temperature, response_format, **kwargs
+            )
+
+            # Update stats
+            self.stats_manager.record_success(
+                tokens=completion_response.tokens_used,
+                cost=completion_response.cost_usd,
+                model=model,
+                provider=provider
+            )
+
+            return completion_response
+
+        except Exception as e:
+            self.stats_manager.record_failure()
+            logger.error(f"Chat completion failed: {e}")
+            raise
+
+    def _prepare_api_model(self, model: str, provider: str) -> str:
+        """
+        Prepare model name for API call.
+
+        For OpenAI, remove provider prefix if present.
+
+        Args:
+            model: Model name
+            provider: Provider name
+
+        Returns:
+            API-ready model name
+        """
+        api_model = model
+        if provider == "openai" and model.startswith("openai/"):
+            api_model = model.replace("openai/", "")
+        return api_model
+
+    def _make_api_call(
+        self,
+        client,
+        model: str,
+        messages: List[Dict[str, str]],
+        max_tokens: Optional[int],
+        temperature: Optional[float],
+        response_format: Optional[str],
+        **kwargs
+    ):
+        """
+        Make actual API call.
+
+        Args:
+            client: OpenAI client
+            model: Model to use
+            messages: Chat messages
+            max_tokens: Max tokens
+            temperature: Temperature
+            response_format: Response format
+            **kwargs: Additional parameters
+
+        Returns:
+            API response
+        """
+        params = {
+            "model": model,
+            "messages": messages,
+            "stream": False
+        }
+
+        # Add optional parameters
+        if max_tokens is not None:
+            params["max_tokens"] = max_tokens
+        if temperature is not None:
+            params["temperature"] = temperature
+        if response_format:
+            params["response_format"] = {"type": response_format}
+
+        # Add any additional kwargs
+        params.update(kwargs)
+
+        logger.debug(f"Making chat completion request with model: {model}")
+        return client.chat.completions.create(**params)

django_cfg/modules/django_llm/llm/requests/embedding_handler.py

@@ -0,0 +1,113 @@
+"""
+Embedding request handler for LLM client.
+
+Handles embedding generation requests with provider-specific strategies.
+"""
+
+import logging
+from typing import TYPE_CHECKING
+
+from ..models import EmbeddingResponse
+
+if TYPE_CHECKING:
+    from ..providers import ProviderManager, ProviderSelector
+    from ..embeddings import OpenAIEmbedder, MockEmbedder
+    from ..stats import StatsManager
+    from .cache_manager import RequestCacheManager
+
+logger = logging.getLogger(__name__)
+
+
+class EmbeddingRequestHandler:
+    """Handles embedding generation requests."""
+
+    def __init__(
+        self,
+        provider_manager: 'ProviderManager',
+        provider_selector: 'ProviderSelector',
+        cache_manager: 'RequestCacheManager',
+        stats_manager: 'StatsManager',
+        openai_embedder: 'OpenAIEmbedder',
+        mock_embedder: 'MockEmbedder'
+    ):
+        """
+        Initialize embedding request handler.
+
+        Args:
+            provider_manager: Provider manager instance
+            provider_selector: Provider selector instance
+            cache_manager: Cache manager instance
+            stats_manager: Stats manager instance
+            openai_embedder: OpenAI embedder instance
+            mock_embedder: Mock embedder instance
+        """
+        self.provider_manager = provider_manager
+        self.provider_selector = provider_selector
+        self.cache_manager = cache_manager
+        self.stats_manager = stats_manager
+        self.openai_embedder = openai_embedder
+        self.mock_embedder = mock_embedder
+
+    def generate_embedding(
+        self,
+        text: str,
+        model: str = "text-embedding-ada-002"
+    ) -> EmbeddingResponse:
+        """
+        Generate embedding with provider-specific logic.
+
+        Uses real OpenAI embeddings when available, falls back to mock
+        embeddings for providers without embedding support.
+
+        Args:
+            text: Text to generate embedding for
+            model: Embedding model to use
+
+        Returns:
+            Embedding response with vector and metadata
+
+        Raises:
+            RuntimeError: If embedding generation fails
+        """
+        # Check cache
+        cached_response = self.cache_manager.get_cached_embedding(text, model)
+        if cached_response:
+            self.stats_manager.record_cache_hit()
+            return cached_response
+
+        self.stats_manager.record_cache_miss()
+        self.stats_manager.record_request()
+
+        # Get best provider for embedding
+        provider = self.provider_selector.get_provider_for_task("embedding")
+
+        try:
+            # Generate embedding using appropriate strategy
+            if self.provider_selector.should_use_mock_embedding(provider):
+                # Use mock embedder for OpenRouter
+                logger.debug(f"Using mock embedder for provider: {provider}")
+                result = self.mock_embedder.generate(text, model)
+            else:
+                # Use real OpenAI embeddings
+                logger.debug(f"Using OpenAI embedder for provider: {provider}")
+                client = self.provider_manager.get_client(provider)
+                result = self.openai_embedder.generate(client, text, model)
+
+            # Cache response
+            self.cache_manager.cache_embedding_response(result, text, model)
+
+            # Update stats
+            self.stats_manager.record_success(
+                tokens=result.tokens,
+                cost=result.cost,
+                model=model,
+                provider=provider
+            )
+
+            return result
+
+        except Exception as e:
+            self.stats_manager.record_failure()
+            error_msg = f"Embedding generation failed: {e}"
+            logger.error(error_msg)
+            raise RuntimeError(error_msg) from e

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

@@ -0,0 +1,9 @@
+"""
+Response handling for LLM client.
+
+Builds Pydantic response objects from API responses.
+"""
+
+from .response_builder import ResponseBuilder
+
+__all__ = ['ResponseBuilder']

django_cfg/modules/django_llm/llm/responses/response_builder.py

@@ -0,0 +1,131 @@
+"""
+Response builder for LLM client.
+
+Builds Pydantic response objects from API responses.
+"""
+
+import time
+import logging
+from datetime import datetime
+from typing import Optional
+from openai.types.chat import ChatCompletion
+
+from ..costs import calculate_chat_cost
+from ..models import ChatCompletionResponse, ChatChoice, TokenUsage
+
+logger = logging.getLogger(__name__)
+
+
+class ResponseBuilder:
+    """Builds Pydantic response objects from API responses."""
+
+    def __init__(self, models_cache=None, json_extractor=None):
+        """
+        Initialize response builder.
+
+        Args:
+            models_cache: Optional models cache for cost calculation
+            json_extractor: Optional JSON extractor for parsing JSON responses
+        """
+        self.models_cache = models_cache
+        self.json_extractor = json_extractor
+
+    def build_chat_response(
+        self,
+        api_response: ChatCompletion,
+        model: str,
+        provider: str,
+        response_format: Optional[str] = None,
+        processing_time: float = 0.0
+    ) -> ChatCompletionResponse:
+        """
+        Build ChatCompletionResponse from API response.
+
+        Args:
+            api_response: Raw API response from OpenAI
+            model: Model used for generation
+            provider: Provider used
+            response_format: Response format (e.g., "json")
+            processing_time: Time taken to process request
+
+        Returns:
+            ChatCompletionResponse Pydantic model
+        """
+        # Calculate cost
+        usage_dict = self._extract_usage(api_response)
+        cost_usd = calculate_chat_cost(usage_dict, model, self.models_cache)
+
+        # Extract content
+        content = self._extract_content(api_response)
+
+        # Try to extract JSON if requested
+        extracted_json = None
+        if response_format == "json" and content and self.json_extractor:
+            try:
+                extracted_json = self.json_extractor.extract_json_from_response(content)
+            except Exception as e:
+                logger.warning(f"Failed to extract JSON from response: {e}")
+
+        # Build response object
+        return ChatCompletionResponse(
+            id=api_response.id,
+            model=api_response.model,
+            created=datetime.fromtimestamp(api_response.created).isoformat(),
+            choices=self._build_choices(api_response),
+            usage=self._build_token_usage(api_response.usage),
+            finish_reason=self._extract_finish_reason(api_response),
+            content=content,
+            tokens_used=usage_dict['total_tokens'],
+            cost_usd=cost_usd,
+            processing_time=processing_time,
+            extracted_json=extracted_json
+        )
+
+    def _extract_usage(self, api_response: ChatCompletion) -> dict:
+        """Extract usage dictionary from API response."""
+        if api_response.usage:
+            return api_response.usage.model_dump()
+        return {
+            'total_tokens': 0,
+            'prompt_tokens': 0,
+            'completion_tokens': 0
+        }
+
+    def _extract_content(self, api_response: ChatCompletion) -> str:
+        """Extract content from API response."""
+        if api_response.choices and len(api_response.choices) > 0:
+            return api_response.choices[0].message.content or ""
+        return ""
+
+    def _extract_finish_reason(self, api_response: ChatCompletion) -> Optional[str]:
+        """Extract finish reason from API response."""
+        if api_response.choices and len(api_response.choices) > 0:
+            return api_response.choices[0].finish_reason
+        return None
+
+    def _build_choices(self, api_response: ChatCompletion) -> list:
+        """Build list of ChatChoice objects from API response."""
+        if not api_response.choices:
+            return []
+
+        return [
+            ChatChoice(
+                index=choice.index,
+                message=choice.message.model_dump() if hasattr(choice.message, 'model_dump') else choice.message,
+                finish_reason=choice.finish_reason
+            ) for choice in api_response.choices
+        ]
+
+    def _build_token_usage(self, usage) -> TokenUsage:
+        """Build TokenUsage object from API response usage."""
+        if usage:
+            return TokenUsage(
+                prompt_tokens=usage.prompt_tokens,
+                completion_tokens=usage.completion_tokens,
+                total_tokens=usage.total_tokens
+            )
+        return TokenUsage(
+            prompt_tokens=0,
+            completion_tokens=0,
+            total_tokens=0
+        )

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

@@ -0,0 +1,9 @@
+"""
+Statistics management for LLM client.
+
+Tracks usage, costs, and performance metrics.
+"""
+
+from .stats_manager import StatsManager
+
+__all__ = ['StatsManager']