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

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

@@ -4,14 +4,14 @@ 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
+from ..models import ChatChoice, ChatCompletionResponse, TokenUsage
 
 logger = logging.getLogger(__name__)
 

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

@@ -5,7 +5,7 @@ Tracks requests, cache hits, tokens, costs, and usage patterns.
 """
 
 import logging
-from typing import Dict, Any
+from typing import Any, Dict
 
 logger = logging.getLogger(__name__)
 

django_cfg/modules/django_llm/llm/tokenizer.py

@@ -6,6 +6,7 @@ Provides token counting functionality for various LLM models.
 
 import logging
 from typing import Dict, List
+
 import tiktoken
 
 logger = logging.getLogger(__name__)
@@ -13,11 +14,11 @@ logger = logging.getLogger(__name__)
 
 class Tokenizer:
     """Token counting utility using tiktoken."""
-    
+
     def __init__(self):
         """Initialize tokenizer with encoder cache."""
         self.encoders = {}
-    
+
     def _get_encoder(self, model: str):
         """Get tiktoken encoder for model."""
         if model not in self.encoders:
@@ -28,9 +29,9 @@ class Tokenizer:
             except Exception as e:
                 logger.warning(f"Failed to get encoder for {model}, using cl100k_base: {e}")
                 self.encoders[model] = tiktoken.get_encoding("cl100k_base")
-        
+
         return self.encoders[model]
-    
+
     def _get_encoding_name(self, model: str) -> str:
         """Get encoding name for model."""
         # GPT-4 and GPT-3.5 models use cl100k_base
@@ -42,7 +43,7 @@ class Tokenizer:
         # Default to cl100k_base for most modern models
         else:
             return "cl100k_base"
-    
+
     def count_tokens(self, text: str, model: str) -> int:
         """
         Count tokens in text using tiktoken.
@@ -56,7 +57,7 @@ class Tokenizer:
         """
         encoder = self._get_encoder(model)
         return len(encoder.encode(text))
-    
+
     def count_messages_tokens(self, messages: List[Dict[str, str]], model: str) -> int:
         """
         Count total tokens in messages.
@@ -69,15 +70,15 @@ class Tokenizer:
             Total number of tokens
         """
         total_tokens = 0
-        
+
         for message in messages:
             # Format message as it would be sent to API
             role = message.get('role', 'user')
             content = message.get('content', '')
             formatted_message = f"{role}\n{content}"
             total_tokens += self.count_tokens(formatted_message, model)
-        
+
         # Add overhead for message formatting
         total_tokens += len(messages) * 4  # Rough estimate for message overhead
-        
+
         return total_tokens

django_cfg/modules/django_llm/translator/__init__.py

@@ -2,7 +2,7 @@
 Translation functionality with caching by language pairs
 """
 
-from .translator import DjangoTranslator, TranslationError
 from .cache import TranslationCacheManager
+from .translator import DjangoTranslator, TranslationError
 
 __all__ = ['DjangoTranslator', 'TranslationError', 'TranslationCacheManager']

django_cfg/modules/django_llm/translator/cache.py

@@ -2,18 +2,19 @@
 Translation Cache Manager - stores translations by language pairs like in unreal_llm
 """
 
-import json
 import hashlib
+import json
 import logging
 from pathlib import Path
-from typing import Dict, Optional, Any
+from typing import Any, Dict, Optional
+
 from cachetools import TTLCache
 
 logger = logging.getLogger(__name__)
 
 class TranslationCacheManager:
     """Manages translation caching with TTL and file persistence (per language pair)"""
-    
+
     def __init__(self, cache_dir: Optional[str] = None, ttl_hours: int = 24):
         """
         Initialize translation cache manager
@@ -27,65 +28,65 @@ class TranslationCacheManager:
             # Get the django_cfg module directory
             module_dir = Path(__file__).parent.parent.parent.parent  # django_cfg/modules/django_llm/translator -> django_cfg
             default_cache_dir = module_dir / ".cache" / "llm_translate"
-            
+
             # Create cache directory if it doesn't exist
             default_cache_dir.mkdir(parents=True, exist_ok=True)
         else:
             default_cache_dir = Path(cache_dir)
-            
+
         self.cache_dir = default_cache_dir
         self.ttl_seconds = ttl_hours * 3600
-        
+
         # In-memory cache with TTL (like in unreal_llm)
         self._memory_cache = TTLCache(maxsize=1000, ttl=self.ttl_seconds)
-        
+
         logger.info(f"Translation cache initialized: {self.cache_dir}")
-    
+
     def _get_cache_file(self, source_lang: str, target_lang: str) -> Path:
         """Get cache file path for language pair (like in unreal_llm)"""
         return self.cache_dir / f"{source_lang}→{target_lang}.json"
-    
+
     def _get_text_hash(self, text: str) -> str:
         """Generate hash for text"""
         return hashlib.md5(text.encode('utf-8')).hexdigest()
-    
+
     def _load_file_cache(self, source_lang: str, target_lang: str) -> Dict[str, Any]:
         """Load translations from file cache"""
         cache_file = self._get_cache_file(source_lang, target_lang)
-        
+
         if not cache_file.exists():
             return {}
-            
+
         try:
-            with open(cache_file, 'r', encoding='utf-8') as f:
+            with open(cache_file, encoding='utf-8') as f:
                 return json.load(f)
-        except (json.JSONDecodeError, IOError) as e:
+        except (OSError, json.JSONDecodeError) as e:
             logger.warning(f"Failed to load cache file {cache_file}: {e}")
             return {}
-    
+
     def _save_file_cache(self, source_lang: str, target_lang: str, cache_data: Dict[str, Any]):
         """Save translations to file cache"""
         cache_file = self._get_cache_file(source_lang, target_lang)
-        
+
         try:
             # Ensure directory exists
             cache_file.parent.mkdir(parents=True, exist_ok=True)
-            
+
             with open(cache_file, 'w', encoding='utf-8') as f:
                 json.dump(cache_data, f, ensure_ascii=False, indent=2)
-                
-        except IOError as e:
+
+        except OSError as e:
             logger.error(f"Failed to save cache file {cache_file}: {e}")
-    
+
     def get(self, text: str, source_lang: str, target_lang: str) -> Optional[str]:
         """Get translation from cache"""
         text_hash = self._get_text_hash(text)
         cache_key = f"{source_lang}→{target_lang}:{text_hash}"
-        
+
         # Check memory cache first
         if cache_key in self._memory_cache:
             return self._memory_cache[cache_key]
-        
+
         # Check file cache
         file_cache = self._load_file_cache(source_lang, target_lang)
         if text_hash in file_cache:
@@ -93,24 +94,24 @@ class TranslationCacheManager:
             # Store in memory cache
             self._memory_cache[cache_key] = translation
             return translation
-            
+
         return None
-    
+
     def set(self, text: str, source_lang: str, target_lang: str, translation: str):
         """Store translation in cache"""
         text_hash = self._get_text_hash(text)
         cache_key = f"{source_lang}→{target_lang}:{text_hash}"
-        
+
         # Store in memory cache
         self._memory_cache[cache_key] = translation
-        
+
         # Store in file cache
         file_cache = self._load_file_cache(source_lang, target_lang)
         file_cache[text_hash] = translation
         self._save_file_cache(source_lang, target_lang, file_cache)
-        
+
         logger.debug(f"Cached translation: {source_lang}→{target_lang} ({len(text)} chars)")
-    
+
     def clear(self, source_lang: Optional[str] = None, target_lang: Optional[str] = None):
         """Clear cache (all or specific language pair)"""
         if source_lang and target_lang:
@@ -118,25 +119,25 @@ class TranslationCacheManager:
             cache_file = self._get_cache_file(source_lang, target_lang)
             if cache_file.exists():
                 cache_file.unlink()
-            
+
             # Clear from memory cache
             prefix = f"{source_lang}→{target_lang}:"
             keys_to_remove = [k for k in self._memory_cache.keys() if k.startswith(prefix)]
             for key in keys_to_remove:
                 del self._memory_cache[key]
-                
+
             logger.info(f"Cleared cache for {source_lang}→{target_lang}")
         else:
             # Clear all caches
             self._memory_cache.clear()
-            
+
             # Remove all cache files
             if self.cache_dir.exists():
                 for cache_file in self.cache_dir.glob("*.json"):
                     cache_file.unlink()
-                    
+
             logger.info("Cleared all translation caches")
-    
+
     def get_stats(self) -> Dict[str, Any]:
         """Get cache statistics"""
         stats = {
@@ -144,7 +145,7 @@ class TranslationCacheManager:
             'cache_dir': str(self.cache_dir),
             'language_pairs': []
         }
-        
+
         # Count file caches
         if self.cache_dir.exists():
             for cache_file in self.cache_dir.glob("*.json"):
@@ -155,5 +156,5 @@ class TranslationCacheManager:
                     'translations': len(file_cache),
                     'file_size': cache_file.stat().st_size
                 })
-        
+
         return stats

django_cfg/modules/django_llm/translator/detectors/__init__.py

@@ -4,8 +4,8 @@ Language detection modules.
 Script-based and dictionary-based language detection.
 """
 
-from .script_detector import ScriptDetector
 from .language_detector import LanguageDetector
+from .script_detector import ScriptDetector
 
 __all__ = [
     'ScriptDetector',

django_cfg/modules/django_llm/translator/detectors/script_detector.py

@@ -5,7 +5,6 @@ Detects language based on character scripts (CJK, Cyrillic, etc.).
 """
 
 import re
-from typing import Optional
 
 
 class ScriptDetector:

django_cfg/modules/django_llm/translator/stats/stats_tracker.py

@@ -4,7 +4,7 @@ Translation statistics tracking.
 Tracks translation usage, cache performance, and costs.
 """
 
-from typing import Dict, Any
+from typing import Any, Dict
 
 
 class StatsTracker:

django_cfg/modules/django_llm/translator/translator.py

@@ -5,17 +5,18 @@ Auto-configuring translation service with language detection and JSON support.
 """
 
 import logging
-from typing import Dict, Any, Optional
+from typing import Any, Dict, Optional
 
 from django_cfg.modules import BaseCfgModule
+
 from ..llm.client import LLMClient
 from .cache import TranslationCacheManager
 
 # Import specialized components
-from .detectors import ScriptDetector, LanguageDetector
-from .translators import TextTranslator, JsonTranslator, TranslationError, LanguageDetectionError
-from .utils import TextUtils, PromptBuilder
+from .detectors import LanguageDetector, ScriptDetector
 from .stats import StatsTracker
+from .translators import JsonTranslator, TextTranslator, TranslationError
+from .utils import PromptBuilder, TextUtils
 
 logger = logging.getLogger(__name__)
 

django_cfg/modules/django_llm/translator/translators/__init__.py

@@ -4,8 +4,8 @@ Translation modules.
 Text and JSON translation with caching and batch processing.
 """
 
-from .text_translator import TextTranslator, TranslationError, LanguageDetectionError
 from .json_translator import JsonTranslator
+from .text_translator import LanguageDetectionError, TextTranslator, TranslationError
 
 __all__ = [
     'TextTranslator',

django_cfg/modules/django_llm/translator/translators/json_translator.py

@@ -6,7 +6,7 @@ Handles translation of JSON objects with smart caching and batch processing.
 
 import json
 import logging
-from typing import Dict, Any, List, Set, Optional
+from typing import Any, Dict, List, Optional, Set
 
 logger = logging.getLogger(__name__)
 

django_cfg/modules/django_llm/translator/utils/__init__.py

@@ -4,8 +4,8 @@ Utility modules for translation.
 Text processing and prompt generation utilities.
 """
 
-from .text_utils import TextUtils
 from .prompt_builder import PromptBuilder
+from .text_utils import TextUtils
 
 __all__ = [
     'TextUtils',

django_cfg/modules/django_llm/translator/utils/prompt_builder.py

@@ -4,7 +4,6 @@ Prompt generation for translation.
 Builds prompts for text and JSON translation.
 """
 
-from typing import Dict
 
 
 class PromptBuilder:

django_cfg/modules/django_logging/__init__.py

@@ -4,8 +4,8 @@ Django Logging Modules for django_cfg.
 Auto-configuring logging utilities.
 """
 
-from .logger import logger
 from .django_logger import DjangoLogger, get_logger
+from .logger import logger
 
 __all__ = [
     "logger",

django_cfg/modules/django_logging/django_logger.py

@@ -6,28 +6,27 @@ KISS principle: simple, unified logging configuration.
 
 import logging
 from pathlib import Path
-from typing import Dict, Optional
+from typing import Dict
 
 from ..base import BaseCfgModule
-from ...utils.smart_defaults import get_log_filename
 
 
 class DjangoLogger(BaseCfgModule):
     """Simple auto-configuring logger."""
-    
+
     _loggers: Dict[str, logging.Logger] = {}
     _configured = False
-    
+
     @classmethod
     def get_logger(cls, name: str = "django_cfg") -> logging.Logger:
         """Get a configured logger instance."""
         if not cls._configured:
             cls._setup_logging()
-        
+
         if name not in cls._loggers:
             cls._loggers[name] = cls._create_logger(name)
         return cls._loggers[name]
-    
+
     @classmethod
     def _setup_logging(cls):
         """Setup modular logging configuration with separate files per module."""
@@ -35,15 +34,15 @@ class DjangoLogger(BaseCfgModule):
         current_dir = Path(os.getcwd())
         logs_dir = current_dir / 'logs'
         djangocfg_logs_dir = logs_dir / 'djangocfg'
-        
+
         # Create directories
         logs_dir.mkdir(parents=True, exist_ok=True)
         djangocfg_logs_dir.mkdir(parents=True, exist_ok=True)
-        
+
         # print(f"[django-cfg] Setting up modular logging:")
         # print(f"  Django logs: {logs_dir / 'django.log'}")
         # print(f"  Django-CFG logs: {djangocfg_logs_dir}/")
-        
+
         # Get debug mode
         try:
             from django_cfg.core.state import get_current_config
@@ -51,7 +50,7 @@ class DjangoLogger(BaseCfgModule):
             debug = config.debug if config else False
         except Exception:
             debug = os.getenv('DEBUG', 'false').lower() in ('true', '1', 'yes')
-        
+
         # Create handlers
         try:
             # Handler for general Django logs
@@ -71,17 +70,17 @@ class DjangoLogger(BaseCfgModule):
             # Configure root logger
             root_logger = logging.getLogger()
             root_logger.setLevel(logging.DEBUG if debug else logging.WARNING)
-            
+
             # Clear existing handlers
             root_logger.handlers.clear()
-            
+
             # Add handlers to root logger
             root_logger.addHandler(console_handler)
             root_logger.addHandler(django_handler)  # All logs go to django.log
-            
+
             # print(f"[django-cfg] Modular logging configured successfully! Debug: {debug}")
             cls._configured = True
-            
+
         except Exception as e:
             print(f"[django-cfg] ERROR setting up modular logging: {e}")
             # Fallback to console only
@@ -92,12 +91,12 @@ class DjangoLogger(BaseCfgModule):
                 force=True
             )
             cls._configured = True
-    
+
     @classmethod
     def _create_logger(cls, name: str) -> logging.Logger:
         """Create logger with modular file handling for django-cfg loggers."""
         logger = logging.getLogger(name)
-        
+
         # If this is a django-cfg logger, add a specific file handler
         if name.startswith('django_cfg'):
             try:
@@ -105,7 +104,7 @@ class DjangoLogger(BaseCfgModule):
                 current_dir = Path(os.getcwd())
                 djangocfg_logs_dir = current_dir / 'logs' / 'djangocfg'
                 djangocfg_logs_dir.mkdir(parents=True, exist_ok=True)
-                
+
                 # Extract module name from logger name
                 # e.g., 'django_cfg.payments.provider' -> 'payments'
                 # e.g., 'django_cfg.core' -> 'core'
@@ -115,12 +114,12 @@ class DjangoLogger(BaseCfgModule):
                     module_name = parts[1]  # django_cfg.payments -> payments
                 else:
                     module_name = 'core'  # django_cfg -> core
-                
+
                 log_file_path = djangocfg_logs_dir / f'{module_name}.log'
-                
+
                 # Create file handler for this specific module
                 file_handler = logging.FileHandler(log_file_path, encoding='utf-8')
-                
+
                 # Get debug mode
                 try:
                     from django_cfg.core.state import get_current_config
@@ -130,20 +129,20 @@ class DjangoLogger(BaseCfgModule):
                     debug = os.getenv('DEBUG', 'false').lower() in ('true', '1', 'yes')
 
                 file_handler.setLevel(logging.DEBUG if debug else logging.WARNING)
-                
+
                 # Set format
                 formatter = logging.Formatter('[%(asctime)s] %(levelname)s in %(name)s [%(filename)s:%(lineno)d]: %(message)s')
                 file_handler.setFormatter(formatter)
-                
+
                 # Add handler to logger
                 logger.addHandler(file_handler)
                 logger.propagate = True  # Also send to parent (django.log)
-                
+
                 # print(f"[django-cfg] Created modular logger: {name} -> {log_file_path}")
-                
+
             except Exception as e:
                 print(f"[django-cfg] ERROR creating modular logger for {name}: {e}")
-        
+
         return logger
 
 
@@ -155,7 +154,7 @@ def get_logger(name: str = "django_cfg") -> logging.Logger:
     If called from django-cfg modules, automatically prefixes with 'django_cfg.'
     """
     import inspect
-    
+
     # Auto-detect if we're being called from django-cfg code
     if not name.startswith('django_cfg'):
         # Get the calling frame to determine if we're in django-cfg code
@@ -165,17 +164,17 @@ def get_logger(name: str = "django_cfg") -> logging.Logger:
             caller_frame = frame.f_back
             if caller_frame:
                 caller_filename = caller_frame.f_code.co_filename
-                
+
                 # Check if caller is from django-cfg modules
                 if '/django_cfg/' in caller_filename:
                     # Extract module path from filename
                     # e.g., /path/to/django_cfg/apps/payments/services/providers/registry.py
                     # -> django_cfg.payments.providers
-                    
+
                     parts = caller_filename.split('/django_cfg/')
                     if len(parts) > 1:
                         module_path = parts[1]  # apps/payments/services/providers/registry.py
-                        
+
                         # Convert path to module name
                         if module_path.startswith('apps/'):
                             # apps/payments/services/providers/registry.py -> payments.providers
@@ -186,24 +185,24 @@ def get_logger(name: str = "django_cfg") -> logging.Logger:
                                 for part in path_parts[:-1]:  # Exclude filename
                                     if part not in ['services', 'management', 'commands']:
                                         clean_parts.append(part)
-                                
+
                                 if clean_parts:
                                     auto_name = f"django_cfg.{'.'.join(clean_parts)}"
                                     # print(f"[django-cfg] Auto-detected logger name: {name} -> {auto_name}")
                                     name = auto_name
-                        
+
                         elif module_path.startswith('modules/'):
                             # modules/django_logger.py -> django_cfg.core
                             name = "django_cfg.core"
-                            
+
                         elif module_path.startswith('core/'):
                             # core/config.py -> django_cfg.core
                             name = "django_cfg.core"
         finally:
             del frame
-    
+
     return DjangoLogger.get_logger(name)
 
 
 # Export public API
-__all__ = ['DjangoLogger', 'get_logger']
+__all__ = ['DjangoLogger', 'get_logger']

django_cfg/modules/django_logging/logger.py

@@ -4,19 +4,15 @@ Centralized Logger for Django Config Toolkit
 Provides configurable logging with different levels and formatters.
 """
 
+import json
 import logging
 import os
 import sys
-import json
-from typing import Optional, Dict, Any, Union, List
-from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
 import yaml
 from rich.console import Console
 from rich.logging import RichHandler
-from rich.panel import Panel
-from rich.text import Text
-from rich.table import Table
-from rich.syntax import Syntax
 
 
 class LoggerConfig:

django_cfg/modules/django_ngrok/__init__.py

@@ -6,19 +6,19 @@ Auto-configuring Ngrok integration for local development.
 
 from .service import (
     DjangoNgrok,
-    NgrokManager,
     NgrokError,
+    NgrokManager,
+    get_api_url,
+    get_effective_tunnel_url,
+    get_ngrok_host_from_env,
     get_ngrok_service,
-    start_tunnel,
-    stop_tunnel,
     get_tunnel_url,
-    get_webhook_url,
-    get_api_url,
     get_tunnel_url_from_env,
-    get_ngrok_host_from_env,
+    get_webhook_url,
     is_ngrok_available_from_env,
     is_tunnel_active,
-    get_effective_tunnel_url,
+    start_tunnel,
+    stop_tunnel,
 )
 
 __all__ = [