django-cfg 1.1.75__tar.gz → 1.1.77__tar.gz

{django_cfg-1.1.75 → django_cfg-1.1.77}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-cfg
-Version: 1.1.75
+Version: 1.1.77
 Summary: 🚀 Production-ready Django configuration framework with type-safe settings, smart automation, and modern developer experience
 Project-URL: Homepage, https://github.com/markolofsen/django-cfg
 Project-URL: Documentation, https://django-cfg.readthedocs.io

{django_cfg-1.1.75 → django_cfg-1.1.77}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "django-cfg"
-version = "1.1.75"
+version = "1.1.77"
 description = "🚀 Production-ready Django configuration framework with type-safe settings, smart automation, and modern developer experience"
 readme = "README.md"
 license = {text = "MIT"}

{django_cfg-1.1.75 → django_cfg-1.1.77}/src/django_cfg/__init__.py

@@ -38,7 +38,7 @@ default_app_config = "django_cfg.apps.DjangoCfgConfig"
 from typing import TYPE_CHECKING
 
 # Version information
-__version__ = "1.1.75"
+__version__ = "1.1.77"
 __author__ = "Unrealos Team"
 __email__ = "info@unrealos.com"
 __license__ = "MIT"

{django_cfg-1.1.75 → django_cfg-1.1.77}/src/django_cfg/modules/django_llm/llm/client.py

@@ -26,6 +26,17 @@ from .models_cache import ModelsCache, ModelInfo
 from .costs import calculate_chat_cost, calculate_embedding_cost, estimate_cost
 from .tokenizer import Tokenizer
 from .extractor import JSONExtractor
+from .models import (
+    EmbeddingResponse, 
+    ChatCompletionResponse, 
+    TokenUsage, 
+    ChatChoice,
+    LLMStats,
+    CostEstimate,
+    ValidationResult,
+    CacheInfo,
+    LLMError
+)
 
 logger = logging.getLogger(__name__)
 
@@ -458,7 +469,7 @@ class LLMClient:
             self.models_cache.clear_cache()
         logger.info("LLM client cache cleared")
     
-    def generate_embedding(self, text: str, model: str = "text-embedding-ada-002") -> Dict[str, Any]:
+    def generate_embedding(self, text: str, model: str = "text-embedding-ada-002") -> EmbeddingResponse:
         """
         Generate embedding for text.
         
@@ -484,7 +495,8 @@ class LLMClient:
         if cached_response:
             logger.debug("Cache hit for embedding generation")
             self.stats['cache_hits'] += 1
-            return cached_response
+            # Convert cached dict back to Pydantic model
+            return EmbeddingResponse(**cached_response)
         
         self.stats['cache_misses'] += 1
         self.stats['total_requests'] += 1
@@ -526,16 +538,16 @@ class LLMClient:
                 tokens_used = len(text.split())  # Rough estimate
                 cost = calculate_embedding_cost(tokens_used, model, self.models_cache)
                 
-                result = {
-                    "embedding": mock_embedding,
-                    "tokens": tokens_used,
-                    "cost": cost,
-                    "model": model,
-                    "text_length": len(text),
-                    "dimension": len(mock_embedding),
-                    "response_time": time.time() - start_time,
-                    "warning": "This is a mock embedding, not a real one. OpenRouter doesn't support embedding models."
-                }
+                result = EmbeddingResponse(
+                    embedding=mock_embedding,
+                    tokens=tokens_used,
+                    cost=cost,
+                    model=model,
+                    text_length=len(text),
+                    dimension=len(mock_embedding),
+                    response_time=time.time() - start_time,
+                    warning="This is a mock embedding, not a real one. OpenRouter doesn't support embedding models."
+                )
             else:
                 # Use real OpenAI embedding API
                 response = self.client.embeddings.create(
@@ -551,25 +563,25 @@ class LLMClient:
                 tokens_used = response.usage.total_tokens
                 cost = calculate_embedding_cost(tokens_used, model, self.models_cache)
                 
-                result = {
-                    "embedding": embedding_vector,
-                    "tokens": tokens_used,
-                    "cost": cost,
-                    "model": model,
-                    "text_length": len(text),
-                    "dimension": len(embedding_vector),
-                    "response_time": time.time() - start_time
-                }
+                result = EmbeddingResponse(
+                    embedding=embedding_vector,
+                    tokens=tokens_used,
+                    cost=cost,
+                    model=model,
+                    text_length=len(text),
+                    dimension=len(embedding_vector),
+                    response_time=time.time() - start_time
+                )
             
             # Update statistics
             self.stats['successful_requests'] += 1
-            self.stats['total_tokens_used'] += result["tokens"]
-            self.stats['total_cost_usd'] += result["cost"]
+            self.stats['total_tokens_used'] += result.tokens
+            self.stats['total_cost_usd'] += result.cost
             
-            # Cache the result
-            self.cache.set_response(request_hash, result, model)
+            # Cache the result (convert to dict for caching)
+            self.cache.set_response(request_hash, result.model_dump(), model)
             
-            logger.debug(f"Generated embedding: {result['tokens']} tokens, ${result['cost']:.6f}")
+            logger.debug(f"Generated embedding: {result.tokens} tokens, ${result.cost:.6f}")
             return result
             
         except Exception as e:

django_cfg-1.1.77/src/django_cfg/modules/django_llm/llm/models.py

@@ -0,0 +1,114 @@
+"""
+Pydantic models for LLM client responses.
+"""
+
+from typing import List, Optional, Dict, Any, Union
+from pydantic import BaseModel, Field
+from datetime import datetime
+
+
+class TokenUsage(BaseModel):
+    """Token usage information."""
+    prompt_tokens: int = Field(default=0, description="Number of tokens in the prompt")
+    completion_tokens: int = Field(default=0, description="Number of tokens in the completion")
+    total_tokens: int = Field(default=0, description="Total number of tokens used")
+
+
+class ChatChoice(BaseModel):
+    """Chat completion choice."""
+    index: int = Field(description="Choice index")
+    message: Dict[str, Any] = Field(description="Message content")
+    finish_reason: Optional[str] = Field(default=None, description="Reason for finishing")
+
+
+class ChatCompletionResponse(BaseModel):
+    """Chat completion response from LLM."""
+    id: str = Field(description="Response ID")
+    model: str = Field(description="Model used")
+    created: str = Field(description="Creation timestamp")
+    choices: List[ChatChoice] = Field(default_factory=list, description="Response choices")
+    usage: Optional[TokenUsage] = Field(default=None, description="Token usage")
+    finish_reason: Optional[str] = Field(default=None, description="Finish reason")
+    content: str = Field(description="Response content")
+    tokens_used: int = Field(default=0, description="Total tokens used")
+    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")
+
+
+class EmbeddingResponse(BaseModel):
+    """Embedding generation response from LLM."""
+    embedding: List[float] = Field(description="Generated embedding vector")
+    tokens: int = Field(description="Number of tokens processed")
+    cost: float = Field(description="Cost in USD")
+    model: str = Field(description="Model used for embedding")
+    text_length: int = Field(description="Length of input text")
+    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 = {
+            # Custom encoders if needed
+        }
+
+
+class LLMStats(BaseModel):
+    """LLM client statistics."""
+    successful_requests: int = Field(default=0, description="Number of successful requests")
+    failed_requests: int = Field(default=0, description="Number of failed requests")
+    total_tokens_used: int = Field(default=0, description="Total tokens used")
+    total_cost_usd: float = Field(default=0.0, description="Total cost in USD")
+    model_usage: Dict[str, int] = Field(default_factory=dict, description="Usage per model")
+    provider_usage: Dict[str, int] = Field(default_factory=dict, description="Usage per provider")
+    cache_hits: int = Field(default=0, description="Number of cache hits")
+    cache_misses: int = Field(default=0, description="Number of cache misses")
+
+
+class ModelInfo(BaseModel):
+    """Model information."""
+    id: str = Field(description="Model ID")
+    name: str = Field(description="Model name")
+    provider: str = Field(description="Provider name")
+    max_tokens: int = Field(description="Maximum tokens")
+    input_cost_per_token: float = Field(description="Input cost per token")
+    output_cost_per_token: float = Field(description="Output cost per token")
+    supports_functions: bool = Field(default=False, description="Supports function calling")
+    supports_vision: bool = Field(default=False, description="Supports vision")
+    context_window: int = Field(description="Context window size")
+
+
+class CostEstimate(BaseModel):
+    """Cost estimation result."""
+    estimated_cost: float = Field(description="Estimated cost in USD")
+    input_tokens: int = Field(description="Estimated input tokens")
+    output_tokens: int = Field(description="Estimated output tokens")
+    total_tokens: int = Field(description="Total estimated tokens")
+    model: str = Field(description="Model used for estimation")
+
+
+class ValidationResult(BaseModel):
+    """Validation result for requests."""
+    is_valid: bool = Field(description="Whether the request is valid")
+    errors: List[str] = Field(default_factory=list, description="Validation errors")
+    warnings: List[str] = Field(default_factory=list, description="Validation warnings")
+    estimated_tokens: Optional[int] = Field(default=None, description="Estimated token count")
+    estimated_cost: Optional[float] = Field(default=None, description="Estimated cost")
+
+
+class CacheInfo(BaseModel):
+    """Cache information."""
+    hit: bool = Field(description="Whether it was a cache hit")
+    key: str = Field(description="Cache key")
+    ttl: Optional[int] = Field(default=None, description="Time to live in seconds")
+    size: Optional[int] = Field(default=None, description="Cache entry size")
+
+
+class LLMError(BaseModel):
+    """LLM error information."""
+    error_type: str = Field(description="Type of error")
+    message: str = Field(description="Error message")
+    code: Optional[str] = Field(default=None, description="Error code")
+    details: Optional[Dict[str, Any]] = Field(default=None, description="Additional error details")
+    retry_after: Optional[int] = Field(default=None, description="Retry after seconds")

{django_cfg-1.1.75 → django_cfg-1.1.77}/src/django_cfg/modules/django_llm/llm/models_cache.py

@@ -70,7 +70,8 @@ class ModelsCache:
                 from django.conf import settings
                 if hasattr(settings, 'CACHES') and 'default' in settings.CACHES:
                     cache_location = settings.CACHES['default'].get('LOCATION')
-                    if cache_location:
+                    # Only use cache_location if it's a file path, not a Redis URL
+                    if cache_location and not cache_location.startswith(('redis://', 'rediss://')):
                         self.cache_dir = Path(cache_location) / "django_llm"
                     else:
                         self.cache_dir = Path.cwd() / "cache" / "django_llm"