django-cfg 1.4.20__py3-none-any.whl → 1.4.23__py3-none-any.whl

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

@@ -4,9 +4,8 @@ OpenAI embedder for real embedding generation.
 Uses OpenAI Embeddings API to generate high-quality embeddings.
 """
 
-import time
 import logging
-from typing import Optional
+import time
 
 from ..costs import calculate_embedding_cost
 from ..models import EmbeddingResponse

django_cfg/modules/django_llm/llm/extractor.py

@@ -5,16 +5,16 @@ Provides functionality to extract structured JSON data from LLM text responses.
 """
 
 import json
-import re
 import logging
-from typing import Dict, Any, Optional
+import re
+from typing import Any, Dict, Optional
 
 logger = logging.getLogger(__name__)
 
 
 class JSONExtractor:
     """Utility for extracting JSON from LLM responses."""
-    
+
     @staticmethod
     def extract_json_from_response(content: str) -> Optional[Dict[str, Any]]:
         """
@@ -36,7 +36,7 @@ class JSONExtractor:
                 r'```\s*(\{.*?\})\s*```',
                 r'(\{.*?\})',
             ]
-            
+
             for pattern in json_patterns:
                 matches = re.findall(pattern, content, re.DOTALL)
                 for match in matches:
@@ -44,10 +44,10 @@ class JSONExtractor:
                         return json.loads(match)
                     except json.JSONDecodeError:
                         continue
-            
+
             logger.debug(f"No valid JSON found in response: {content[:100]}...")
             return None
-    
+
     @staticmethod
     def extract_code_blocks(content: str, language: Optional[str] = None) -> list[str]:
         """
@@ -64,10 +64,10 @@ class JSONExtractor:
             pattern = rf'```{language}\s*(.*?)\s*```'
         else:
             pattern = r'```(?:\w+)?\s*(.*?)\s*```'
-        
+
         matches = re.findall(pattern, content, re.DOTALL)
         return [match.strip() for match in matches]
-    
+
     @staticmethod
     def extract_markdown_sections(content: str, section_title: str) -> list[str]:
         """

django_cfg/modules/django_llm/llm/models.py

@@ -3,9 +3,9 @@ Pydantic models for LLM client responses.
 """
 
 import math
-from typing import List, Optional, Dict, Any, Union
+from typing import Any, Dict, List, Optional
+
 from pydantic import BaseModel, Field, validator
-from datetime import datetime
 
 
 class TokenUsage(BaseModel):
@@ -35,14 +35,14 @@ class ChatCompletionResponse(BaseModel):
     cost_usd: float = Field(default=0.0, description="Cost in USD")
     processing_time: float = Field(default=0.0, description="Processing time in seconds")
     extracted_json: Optional[Dict[str, Any]] = Field(default=None, description="Extracted JSON if any")
-    
+
     @validator('cost_usd')
     def validate_cost_usd(cls, v):
         """Validate cost_usd to prevent NaN values."""
         if v is None or math.isnan(v) or math.isinf(v):
             return 0.0
         return v
-    
+
     @validator('processing_time')
     def validate_processing_time(cls, v):
         """Validate processing_time to prevent NaN values."""
@@ -61,7 +61,7 @@ class EmbeddingResponse(BaseModel):
     dimension: int = Field(description="Embedding vector dimension")
     response_time: float = Field(description="Response time in seconds")
     warning: Optional[str] = Field(default=None, description="Warning message if any")
-    
+
     class Config:
         """Pydantic configuration."""
         json_encoders = {

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

@@ -5,9 +5,9 @@ Provides simplified interface to query models cache.
 """
 
 import logging
-from typing import Dict, List, Optional, Any
+from typing import Any, Dict, List, Optional
 
-from ..models_cache import ModelsCache, ModelInfo
+from ..models_cache import ModelInfo, ModelsCache
 
 logger = logging.getLogger(__name__)
 

django_cfg/modules/django_llm/llm/models_cache.py

@@ -6,14 +6,13 @@ Adapted for django-cfg from unreal_llm
 import asyncio
 import json
 import logging
-import time
-from datetime import datetime, timedelta
-from typing import Dict, List, Optional, Any, Union
 from dataclasses import dataclass
+from datetime import datetime, timedelta
 from pathlib import Path
-from cachetools import TTLCache
+from typing import Any, Dict, List, Optional
+
 import aiohttp
-from pydantic import BaseModel, Field
+from cachetools import TTLCache
 
 logger = logging.getLogger(__name__)
 
@@ -38,12 +37,12 @@ class ModelInfo:
 
 class ModelsCache:
     """Cache for OpenRouter models with pricing information"""
-    
+
     DEFAULT_TTL = 86400  # 24 hours default
     DEFAULT_CACHE_SIZE = 100
     CACHE_FILENAME = "openrouter_models.json"
-    
-    def __init__(self, 
+
+    def __init__(self,
                  api_key: str,
                  cache_dir: Optional[Path] = None,
                  cache_ttl: int = DEFAULT_TTL,
@@ -60,7 +59,7 @@ class ModelsCache:
         self.api_key = api_key
         self.cache_ttl = cache_ttl
         self.max_cache_size = max_cache_size
-        
+
         # Determine cache directory
         if cache_dir:
             self.cache_dir = Path(cache_dir)
@@ -79,31 +78,31 @@ class ModelsCache:
                     self.cache_dir = Path.cwd() / "cache" / "django_llm"
             except:
                 self.cache_dir = Path.cwd() / "cache" / "django_llm"
-        
+
         # Ensure cache directory exists
         self.cache_dir.mkdir(parents=True, exist_ok=True)
         self.cache_file = self.cache_dir / self.CACHE_FILENAME
-        
+
         # Memory cache
         self.cache = TTLCache(maxsize=max_cache_size, ttl=cache_ttl)
         self.last_fetch_time: Optional[datetime] = None
         self.models: Dict[str, ModelInfo] = {}
-        
+
         # Cache key for models list
         self.models_cache_key = "openrouter_models"
-        
+
         # Load from file cache on initialization
         self._load_from_file()
-    
+
     def _load_from_file(self) -> bool:
         """Load models from file cache"""
         try:
             if not self.cache_file.exists():
                 return False
-            
-            with open(self.cache_file, 'r', encoding='utf-8') as f:
+
+            with open(self.cache_file, encoding='utf-8') as f:
                 data = json.load(f)
-            
+
             # Check if cache is still valid
             fetch_time_str = data.get('fetch_time')
             if fetch_time_str:
@@ -111,11 +110,11 @@ class ModelsCache:
                 if datetime.now() - fetch_time > timedelta(seconds=self.cache_ttl):
                     logger.debug("File cache expired")
                     return False
-            
+
             # Parse models
             models_data = data.get('models', {})
             self.models = {}
-            
+
             for model_id, model_data in models_data.items():
                 try:
                     pricing = ModelPricing(
@@ -123,7 +122,7 @@ class ModelsCache:
                         completion_price=model_data['pricing']['completion_price'],
                         currency=model_data['pricing']['currency']
                     )
-                    
+
                     model_info = ModelInfo(
                         id=model_data['id'],
                         name=model_data['name'],
@@ -134,29 +133,29 @@ class ModelsCache:
                         tags=model_data.get('tags', []),
                         is_available=model_data.get('is_available', True)
                     )
-                    
+
                     self.models[model_id] = model_info
-                    
+
                 except Exception as e:
                     logger.warning(f"Failed to parse cached model {model_id}: {e}")
                     continue
-            
+
             if fetch_time_str:
                 self.last_fetch_time = datetime.fromisoformat(fetch_time_str)
-            
+
             # Also update memory cache
             self.cache[self.models_cache_key] = {
                 "models": self.models,
                 "fetch_time": self.last_fetch_time
             }
-            
+
             logger.info(f"Loaded {len(self.models)} models from file cache")
             return True
-            
+
         except Exception as e:
             logger.warning(f"Failed to load models from file cache: {e}")
             return False
-    
+
     def _save_to_file(self) -> bool:
         """Save models to file cache"""
         try:
@@ -177,27 +176,27 @@ class ModelsCache:
                     'tags': model_info.tags,
                     'is_available': model_info.is_available
                 }
-            
+
             data = {
                 'models': models_data,
                 'fetch_time': self.last_fetch_time.isoformat() if self.last_fetch_time else None,
                 'cache_ttl': self.cache_ttl,
                 'total_models': len(self.models)
             }
-            
+
             # Write to file atomically
             temp_file = self.cache_file.with_suffix('.tmp')
             with open(temp_file, 'w', encoding='utf-8') as f:
                 json.dump(data, f, indent=2, ensure_ascii=False)
-            
+
             temp_file.replace(self.cache_file)
             logger.debug(f"Saved {len(self.models)} models to file cache")
             return True
-            
+
         except Exception as e:
             logger.error(f"Failed to save models to file cache: {e}")
             return False
-    
+
     async def fetch_models(self, force_refresh: bool = False) -> Dict[str, ModelInfo]:
         """
         Fetch models from OpenRouter API
@@ -215,7 +214,7 @@ class ModelsCache:
             self.models = cached_data["models"]
             self.last_fetch_time = cached_data["fetch_time"]
             return self.models
-        
+
         # Check if we have models from file cache and they're still valid
         if not force_refresh and self.models and self.last_fetch_time:
             if datetime.now() - self.last_fetch_time < timedelta(seconds=self.cache_ttl):
@@ -226,9 +225,9 @@ class ModelsCache:
                     "fetch_time": self.last_fetch_time
                 }
                 return self.models
-        
+
         logger.info("Fetching models from OpenRouter API")
-        
+
         try:
             async with aiohttp.ClientSession() as session:
                 async with session.get(
@@ -241,27 +240,27 @@ class ModelsCache:
                 ) as response:
                     response.raise_for_status()
                     data = await response.json()
-                    
+
                     # Parse models
                     self.models = {}
                     for model_data in data.get("data", []):
                         model_info = self._parse_model_data(model_data)
                         if model_info:
                             self.models[model_info.id] = model_info
-                    
+
                     # Update cache
                     self.last_fetch_time = datetime.now()
                     self.cache[self.models_cache_key] = {
                         "models": self.models,
                         "fetch_time": self.last_fetch_time
                     }
-                    
+
                     # Save to file
                     self._save_to_file()
-                    
+
                     logger.info(f"Fetched {len(self.models)} models from OpenRouter")
                     return self.models
-                    
+
         except aiohttp.ClientError as e:
             logger.error(f"Failed to fetch models: {e}")
             # Return cached models if available
@@ -276,14 +275,14 @@ class ModelsCache:
                 logger.info(f"Using stale cached models ({len(self.models)} models)")
                 return self.models
             raise
-    
+
     def _parse_model_data(self, model_data: Dict[str, Any]) -> Optional[ModelInfo]:
         """Parse model data from API response"""
         try:
             # Check required fields
             if not model_data.get("id") or not model_data.get("name"):
                 return None
-                
+
             # Extract pricing information
             pricing_data = model_data.get("pricing", {})
             pricing = ModelPricing(
@@ -291,7 +290,7 @@ class ModelsCache:
                 completion_price=pricing_data.get("completion", 0.0),
                 currency=pricing_data.get("currency", "USD")
             )
-            
+
             # Create model info
             model_info = ModelInfo(
                 id=model_data.get("id", ""),
@@ -303,23 +302,23 @@ class ModelsCache:
                 tags=model_data.get("tags", []),
                 is_available=model_data.get("available", True)
             )
-            
+
             return model_info
-            
+
         except Exception as e:
             logger.warning(f"Failed to parse model data: {e}")
             return None
-    
+
     def get_model(self, model_id: str) -> Optional[ModelInfo]:
         """Get model information by ID"""
         return self.models.get(model_id)
-    
+
     def get_models_by_provider(self, provider: str) -> List[ModelInfo]:
         """Get all models from a specific provider"""
         return [model for model in self.models.values() if model.provider == provider]
-    
-    def get_models_by_price_range(self, 
-                                 min_price: float = 0.0, 
+
+    def get_models_by_price_range(self,
+                                 min_price: float = 0.0,
                                  max_price: float = float('inf'),
                                  price_type: str = "prompt") -> List[ModelInfo]:
         """
@@ -334,59 +333,59 @@ class ModelsCache:
             List of models in price range
         """
         filtered_models = []
-        
+
         for model in self.models.values():
             if not model.is_available:
                 continue
-                
+
             price = model.pricing.prompt_price if price_type == "prompt" else model.pricing.completion_price
-            
+
             if min_price <= price <= max_price:
                 filtered_models.append(model)
-        
+
         # Sort by price
         filtered_models.sort(key=lambda m: m.pricing.prompt_price if price_type == "prompt" else m.pricing.completion_price)
-        
+
         return filtered_models
-    
+
     def get_free_models(self) -> List[ModelInfo]:
         """Get all free models (price = 0)"""
         return self.get_models_by_price_range(0.0, 0.0)
-    
+
     def get_budget_models(self, max_price: float = 1.0) -> List[ModelInfo]:
         """Get budget models (price <= max_price)"""
         return self.get_models_by_price_range(0.0, max_price)
-    
+
     def get_premium_models(self, min_price: float = 10.0) -> List[ModelInfo]:
         """Get premium models (price >= min_price)"""
         return self.get_models_by_price_range(min_price, float('inf'))
-    
+
     def search_models(self, query: str) -> List[ModelInfo]:
         """Search models by name, description, or tags"""
         query_lower = query.lower()
         results = []
-        
+
         for model in self.models.values():
             # Search in name
             if query_lower in model.name.lower():
                 results.append(model)
                 continue
-            
+
             # Search in description
             if model.description and query_lower in model.description.lower():
                 results.append(model)
                 continue
-            
+
             # Search in tags
             if any(query_lower in tag.lower() for tag in model.tags):
                 results.append(model)
                 continue
-        
+
         return results
-    
-    def get_model_cost_estimate(self, 
-                               model_id: str, 
-                               input_tokens: int, 
+
+    def get_model_cost_estimate(self,
+                               model_id: str,
+                               input_tokens: int,
                                output_tokens: int) -> Optional[float]:
         """
         Estimate cost for a model
@@ -402,13 +401,13 @@ class ModelsCache:
         model = self.get_model(model_id)
         if not model:
             return None
-        
+
         # Calculate cost
         input_cost = (input_tokens / 1_000_000) * model.pricing.prompt_price
         output_cost = (output_tokens / 1_000_000) * model.pricing.completion_price
-        
+
         return input_cost + output_cost
-    
+
     def calculate_cost_from_usage(self, model_id: str, usage: Dict[str, int]) -> Optional[float]:
         """
         Calculate cost from OpenAI usage object
@@ -423,16 +422,16 @@ class ModelsCache:
         model = self.get_model(model_id)
         if not model:
             return None
-        
+
         prompt_tokens = usage.get('prompt_tokens', 0)
         completion_tokens = usage.get('completion_tokens', 0)
-        
+
         # Calculate cost
         input_cost = (prompt_tokens / 1_000_000) * model.pricing.prompt_price
         output_cost = (completion_tokens / 1_000_000) * model.pricing.completion_price
-        
+
         return input_cost + output_cost
-    
+
     def get_cache_info(self) -> Dict[str, Any]:
         """Get cache information"""
         return {
@@ -444,13 +443,13 @@ class ModelsCache:
             "cache_file": str(self.cache_file),
             "cache_file_exists": self.cache_file.exists()
         }
-    
+
     def clear_cache(self):
         """Clear the cache"""
         self.cache.clear()
         self.models.clear()
         self.last_fetch_time = None
-        
+
         # Also remove file cache
         try:
             if self.cache_file.exists():
@@ -458,26 +457,26 @@ class ModelsCache:
                 logger.info("Removed file cache")
         except Exception as e:
             logger.warning(f"Failed to remove file cache: {e}")
-        
+
         logger.info("Models cache cleared")
-    
+
     def get_models_summary(self) -> Dict[str, Any]:
         """Get summary of available models"""
         if not self.models:
             return {"error": "No models loaded"}
-        
+
         # Count by provider
         provider_counts = {}
         for model in self.models.values():
             provider_counts[model.provider] = provider_counts.get(model.provider, 0) + 1
-        
+
         # Price ranges
         prices = [model.pricing.prompt_price for model in self.models.values() if model.is_available]
-        
+
         # Count free models (both prompt and completion prices are 0)
-        free_models = [m for m in self.models.values() 
+        free_models = [m for m in self.models.values()
                       if m.is_available and m.pricing.prompt_price == 0.0 and m.pricing.completion_price == 0.0]
-        
+
         return {
             "total_models": len(self.models),
             "available_models": len([m for m in self.models.values() if m.is_available]),
@@ -497,45 +496,45 @@ class ModelsCache:
 async def example_models_cache():
     """Example usage of ModelsCache"""
     import os
-    
+
     api_key = os.getenv("OPENROUTER_API_KEY")
     if not api_key:
         print("Please set OPENROUTER_API_KEY environment variable")
         return
-    
+
     # Initialize cache
     cache = ModelsCache(api_key=api_key, cache_ttl=86400)  # 24 hours
-    
+
     try:
         # Fetch models
         models = await cache.fetch_models()
         print(f"Fetched {len(models)} models")
-        
+
         # Get summary
         summary = cache.get_models_summary()
         print(f"Summary: {summary}")
-        
+
         # Get free models
         free_models = cache.get_free_models()
         print(f"Free models: {len(free_models)}")
         for model in free_models[:5]:  # Show first 5
             print(f"  - {model.name} ({model.provider})")
-        
+
         # Get budget models
         budget_models = cache.get_budget_models(max_price=0.5)
         print(f"Budget models (≤$0.5/1M tokens): {len(budget_models)}")
-        
+
         # Search for coding models
         coding_models = cache.search_models("code")
         print(f"Coding models: {len(coding_models)}")
         for model in coding_models[:3]:
             print(f"  - {model.name}: ${model.pricing.prompt_price}/1M tokens")
-        
+
         # Estimate cost
         model_id = "openai/gpt-4o-mini"
         cost = cache.get_model_cost_estimate(model_id, 1000, 500)
         print(f"Cost for {model_id} (1000 input + 500 output tokens): ${cost:.6f}")
-        
+
     except Exception as e:
         print(f"Error: {e}")
 

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

@@ -5,7 +5,7 @@ Builds provider-specific configurations and headers.
 """
 
 import logging
-from typing import Dict, Any, Optional
+from typing import Any, Dict, Optional
 
 logger = logging.getLogger(__name__)
 

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

@@ -5,7 +5,8 @@ Manages initialization and access to LLM provider clients.
 """
 
 import logging
-from typing import Dict, Optional, Any
+from typing import Any, Dict, Optional
+
 from openai import OpenAI
 
 from .config_builder import ConfigBuilder

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

@@ -5,8 +5,8 @@ Manages caching of chat and embedding requests.
 """
 
 import logging
-from typing import Optional, Dict, Any, List
 from pathlib import Path
+from typing import Any, Dict, List, Optional
 
 from ..cache import LLMCache
 from ..models import ChatCompletionResponse, EmbeddingResponse

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

@@ -4,9 +4,9 @@ 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
+import time
+from typing import TYPE_CHECKING, Dict, List, Optional
 
 from ..models import ChatCompletionResponse
 from ..providers import ConfigBuilder

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

@@ -10,8 +10,8 @@ from typing import TYPE_CHECKING
 from ..models import EmbeddingResponse
 
 if TYPE_CHECKING:
+    from ..embeddings import MockEmbedder, OpenAIEmbedder
     from ..providers import ProviderManager, ProviderSelector
-    from ..embeddings import OpenAIEmbedder, MockEmbedder
     from ..stats import StatsManager
     from .cache_manager import RequestCacheManager