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

django_cfg/apps/agents/toolsets/cache_toolset.py

@@ -3,10 +3,11 @@ Django cache toolset for caching operations.
 """
 
 import logging
-from typing import Any, Optional, Dict, List
-from pydantic_ai.toolsets import AbstractToolset
-from pydantic_ai import RunContext
+from typing import Any, Dict, List, Optional
+
 from django.core.cache import cache, caches
+from pydantic_ai import RunContext
+from pydantic_ai.toolsets import AbstractToolset
 
 from ..core.dependencies import DjangoDeps
 
@@ -23,7 +24,7 @@ class CacheToolset(AbstractToolset[DjangoDeps]):
     - Cache statistics
     - Multi-cache support
     """
-    
+
     def __init__(self, cache_alias: str = 'default', key_prefix: str = 'orchestrator'):
         """
         Initialize cache toolset.
@@ -34,41 +35,41 @@ class CacheToolset(AbstractToolset[DjangoDeps]):
         """
         self.cache_alias = cache_alias
         self.key_prefix = key_prefix
-    
+
     @property
     def id(self) -> str:
         return f"django_cache_{self.cache_alias}"
-    
+
     def _get_cache(self):
         """Get cache instance."""
         if self.cache_alias == 'default':
             return cache
         else:
             return caches[self.cache_alias]
-    
+
     def _make_key(self, key: str, user_id: Optional[int] = None) -> str:
         """Create cache key with prefix and optional user scope."""
         parts = [self.key_prefix]
-        
+
         if user_id:
             parts.append(f"user_{user_id}")
-        
+
         parts.append(key)
-        
+
         return ':'.join(parts)
-    
+
     async def get_cached_value(
-        self, 
-        ctx: RunContext[DjangoDeps], 
+        self,
+        ctx: RunContext[DjangoDeps],
         key: str,
         user_scoped: bool = False
     ) -> Any:
         """Get value from cache."""
         cache_instance = self._get_cache()
-        
+
         user_id = ctx.deps.user.id if user_scoped else None
         cache_key = self._make_key(key, user_id)
-        
+
         try:
             value = cache_instance.get(cache_key)
             logger.debug(f"Cache get: {cache_key} -> {'HIT' if value is not None else 'MISS'}")
@@ -76,10 +77,10 @@ class CacheToolset(AbstractToolset[DjangoDeps]):
         except Exception as e:
             logger.error(f"Cache get failed for key '{cache_key}': {e}")
             return None
-    
+
     async def set_cached_value(
-        self, 
-        ctx: RunContext[DjangoDeps], 
+        self,
+        ctx: RunContext[DjangoDeps],
         key: str,
         value: Any,
         timeout: Optional[int] = None,
@@ -87,10 +88,10 @@ class CacheToolset(AbstractToolset[DjangoDeps]):
     ) -> bool:
         """Set value in cache."""
         cache_instance = self._get_cache()
-        
+
         user_id = ctx.deps.user.id if user_scoped else None
         cache_key = self._make_key(key, user_id)
-        
+
         try:
             cache_instance.set(cache_key, value, timeout)
             logger.debug(f"Cache set: {cache_key} (timeout: {timeout})")
@@ -98,19 +99,19 @@ class CacheToolset(AbstractToolset[DjangoDeps]):
         except Exception as e:
             logger.error(f"Cache set failed for key '{cache_key}': {e}")
             return False
-    
+
     async def delete_cached_value(
-        self, 
-        ctx: RunContext[DjangoDeps], 
+        self,
+        ctx: RunContext[DjangoDeps],
         key: str,
         user_scoped: bool = False
     ) -> bool:
         """Delete value from cache."""
         cache_instance = self._get_cache()
-        
+
         user_id = ctx.deps.user.id if user_scoped else None
         cache_key = self._make_key(key, user_id)
-        
+
         try:
             result = cache_instance.delete(cache_key)
             logger.debug(f"Cache delete: {cache_key} -> {result}")
@@ -118,10 +119,10 @@ class CacheToolset(AbstractToolset[DjangoDeps]):
         except Exception as e:
             logger.error(f"Cache delete failed for key '{cache_key}': {e}")
             return False
-    
+
     async def get_or_set_cached_value(
-        self, 
-        ctx: RunContext[DjangoDeps], 
+        self,
+        ctx: RunContext[DjangoDeps],
         key: str,
         default_value: Any,
         timeout: Optional[int] = None,
@@ -129,10 +130,10 @@ class CacheToolset(AbstractToolset[DjangoDeps]):
     ) -> Any:
         """Get value from cache or set default if not exists."""
         cache_instance = self._get_cache()
-        
+
         user_id = ctx.deps.user.id if user_scoped else None
         cache_key = self._make_key(key, user_id)
-        
+
         try:
             value = cache_instance.get_or_set(cache_key, default_value, timeout)
             logger.debug(f"Cache get_or_set: {cache_key}")
@@ -140,20 +141,20 @@ class CacheToolset(AbstractToolset[DjangoDeps]):
         except Exception as e:
             logger.error(f"Cache get_or_set failed for key '{cache_key}': {e}")
             return default_value
-    
+
     async def increment_cached_value(
-        self, 
-        ctx: RunContext[DjangoDeps], 
+        self,
+        ctx: RunContext[DjangoDeps],
         key: str,
         delta: int = 1,
         user_scoped: bool = False
     ) -> Optional[int]:
         """Increment numeric value in cache."""
         cache_instance = self._get_cache()
-        
+
         user_id = ctx.deps.user.id if user_scoped else None
         cache_key = self._make_key(key, user_id)
-        
+
         try:
             # Check if cache backend supports increment
             if hasattr(cache_instance, 'incr'):
@@ -174,16 +175,16 @@ class CacheToolset(AbstractToolset[DjangoDeps]):
         except Exception as e:
             logger.error(f"Cache increment failed for key '{cache_key}': {e}")
             return None
-    
+
     async def get_cache_keys(
-        self, 
-        ctx: RunContext[DjangoDeps], 
+        self,
+        ctx: RunContext[DjangoDeps],
         pattern: Optional[str] = None,
         user_scoped: bool = False
     ) -> List[str]:
         """Get cache keys matching pattern."""
         cache_instance = self._get_cache()
-        
+
         # This is backend-dependent and may not work with all cache backends
         try:
             if hasattr(cache_instance, 'keys'):
@@ -193,7 +194,7 @@ class CacheToolset(AbstractToolset[DjangoDeps]):
                     keys = cache_instance.keys(search_pattern)
                 else:
                     keys = cache_instance.keys(f"{self.key_prefix}:*")
-                
+
                 return list(keys)
             else:
                 logger.warning("Cache backend does not support key listing")
@@ -201,35 +202,35 @@ class CacheToolset(AbstractToolset[DjangoDeps]):
         except Exception as e:
             logger.error(f"Failed to get cache keys: {e}")
             return []
-    
+
     async def clear_user_cache(self, ctx: RunContext[DjangoDeps]) -> bool:
         """Clear all cache entries for current user."""
         user_id = ctx.deps.user.id
         pattern = f"{self.key_prefix}:user_{user_id}:*"
-        
+
         try:
             keys = await self.get_cache_keys(ctx, pattern="*", user_scoped=True)
-            
+
             if keys:
                 cache_instance = self._get_cache()
                 cache_instance.delete_many(keys)
                 logger.info(f"Cleared {len(keys)} cache entries for user {user_id}")
-            
+
             return True
         except Exception as e:
             logger.error(f"Failed to clear user cache for user {user_id}: {e}")
             return False
-    
+
     async def get_cache_stats(self, ctx: RunContext[DjangoDeps]) -> Dict[str, Any]:
         """Get cache statistics (if supported by backend)."""
         cache_instance = self._get_cache()
-        
+
         stats = {
             'cache_alias': self.cache_alias,
             'key_prefix': self.key_prefix,
             'backend': cache_instance.__class__.__name__,
         }
-        
+
         try:
             # Try to get backend-specific stats
             if hasattr(cache_instance, '_cache') and hasattr(cache_instance._cache, 'get_stats'):
@@ -244,30 +245,30 @@ class CacheToolset(AbstractToolset[DjangoDeps]):
                     'connected_clients': info.get('connected_clients'),
                     'total_commands_processed': info.get('total_commands_processed'),
                 }
-            
+
             # Get key count if possible
             keys = await self.get_cache_keys(ctx)
             stats['total_keys'] = len(keys)
-            
+
         except Exception as e:
             logger.warning(f"Could not get cache stats: {e}")
             stats['error'] = str(e)
-        
+
         return stats
-    
+
     async def touch_cached_value(
-        self, 
-        ctx: RunContext[DjangoDeps], 
+        self,
+        ctx: RunContext[DjangoDeps],
         key: str,
         timeout: Optional[int] = None,
         user_scoped: bool = False
     ) -> bool:
         """Update cache key timeout without changing value."""
         cache_instance = self._get_cache()
-        
+
         user_id = ctx.deps.user.id if user_scoped else None
         cache_key = self._make_key(key, user_id)
-        
+
         try:
             if hasattr(cache_instance, 'touch'):
                 result = cache_instance.touch(cache_key, timeout)

django_cfg/apps/agents/toolsets/django_toolset.py

@@ -3,9 +3,10 @@ Core Django toolset with common Django operations.
 """
 
 import logging
-from typing import Dict, Any, List, Optional
-from pydantic_ai.toolsets import AbstractToolset
+from typing import Any, Dict, List, Optional
+
 from pydantic_ai import RunContext
+from pydantic_ai.toolsets import AbstractToolset
 
 from ..core.dependencies import DjangoDeps
 
@@ -22,15 +23,15 @@ class DjangoToolset(AbstractToolset[DjangoDeps]):
     - Settings access
     - Logging
     """
-    
+
     @property
     def id(self) -> str:
         return "django_core"
-    
+
     async def get_user_info(self, ctx: RunContext[DjangoDeps]) -> Dict[str, Any]:
         """Get current user information."""
         user = ctx.deps.user
-        
+
         return {
             'id': user.id,
             'username': user.username,
@@ -43,19 +44,19 @@ class DjangoToolset(AbstractToolset[DjangoDeps]):
             'date_joined': user.date_joined.isoformat() if user.date_joined else None,
             'last_login': user.last_login.isoformat() if user.last_login else None,
         }
-    
+
     async def get_user_permissions(self, ctx: RunContext[DjangoDeps]) -> List[str]:
         """Get user permissions."""
         user = ctx.deps.user
-        
+
         # Get all permissions
         permissions = []
-        
+
         # Direct user permissions
         user_perms = await user.user_permissions.aall()
         async for perm in user_perms:
             permissions.append(f"{perm.content_type.app_label}.{perm.codename}")
-        
+
         # Group permissions
         groups = await user.groups.aall()
         async for group in groups:
@@ -64,49 +65,49 @@ class DjangoToolset(AbstractToolset[DjangoDeps]):
                 perm_str = f"{perm.content_type.app_label}.{perm.codename}"
                 if perm_str not in permissions:
                     permissions.append(perm_str)
-        
+
         return sorted(permissions)
-    
+
     async def check_permission(self, ctx: RunContext[DjangoDeps], permission: str) -> bool:
         """Check if user has specific permission."""
         user = ctx.deps.user
-        
+
         # Handle superuser
         if user.is_superuser:
             return True
-        
+
         # Check permission
         return user.has_perm(permission)
-    
+
     async def get_session_data(self, ctx: RunContext[DjangoDeps], key: Optional[str] = None) -> Any:
         """Get session data."""
         session_data = ctx.deps.session_data
-        
+
         if key:
             return session_data.get(key)
-        
+
         return session_data
-    
+
     async def log_message(
-        self, 
-        ctx: RunContext[DjangoDeps], 
-        message: str, 
+        self,
+        ctx: RunContext[DjangoDeps],
+        message: str,
         level: str = "info",
         extra_data: Optional[Dict[str, Any]] = None
     ) -> bool:
         """Log message with user context."""
         user = ctx.deps.user
-        
+
         # Prepare log data
         log_data = {
             'user_id': user.id,
             'username': user.username,
             'message': message,
         }
-        
+
         if extra_data:
             log_data.update(extra_data)
-        
+
         # Log based on level
         if level.lower() == 'debug':
             logger.debug(message, extra=log_data)
@@ -120,13 +121,13 @@ class DjangoToolset(AbstractToolset[DjangoDeps]):
             logger.critical(message, extra=log_data)
         else:
             logger.info(message, extra=log_data)
-        
+
         return True
-    
+
     async def get_django_setting(self, ctx: RunContext[DjangoDeps], setting_name: str) -> Any:
         """Get Django setting value (safe settings only)."""
         from django.conf import settings
-        
+
         # Whitelist of safe settings to expose
         safe_settings = {
             'DEBUG',
@@ -138,19 +139,19 @@ class DjangoToolset(AbstractToolset[DjangoDeps]):
             'STATIC_URL',
             'DEFAULT_AUTO_FIELD',
         }
-        
+
         if setting_name not in safe_settings:
             raise ValueError(f"Setting '{setting_name}' is not in the safe settings list")
-        
+
         return getattr(settings, setting_name, None)
-    
+
     async def get_app_config(self, ctx: RunContext[DjangoDeps], app_label: str) -> Dict[str, Any]:
         """Get Django app configuration."""
         from django.apps import apps
-        
+
         try:
             app_config = apps.get_app_config(app_label)
-            
+
             return {
                 'name': app_config.name,
                 'label': app_config.label,
@@ -161,40 +162,40 @@ class DjangoToolset(AbstractToolset[DjangoDeps]):
         except Exception as e:
             logger.error(f"Failed to get app config for '{app_label}': {e}")
             return {}
-    
+
     async def format_datetime(
-        self, 
-        ctx: RunContext[DjangoDeps], 
-        datetime_str: str, 
+        self,
+        ctx: RunContext[DjangoDeps],
+        datetime_str: str,
         format_str: str = "%Y-%m-%d %H:%M:%S"
     ) -> str:
         """Format datetime string using Django's timezone handling."""
         from django.utils import timezone
         from django.utils.dateparse import parse_datetime
-        
+
         try:
             # Parse datetime
             dt = parse_datetime(datetime_str)
             if not dt:
                 return datetime_str
-            
+
             # Convert to user's timezone if available
             if hasattr(ctx.deps, 'request') and ctx.deps.request:
                 # Use request timezone if available
                 dt = timezone.localtime(dt)
-            
+
             return dt.strftime(format_str)
         except Exception as e:
             logger.error(f"Failed to format datetime '{datetime_str}': {e}")
             return datetime_str
-    
+
     async def get_model_info(self, ctx: RunContext[DjangoDeps], app_label: str, model_name: str) -> Dict[str, Any]:
         """Get Django model information."""
         from django.apps import apps
-        
+
         try:
             model = apps.get_model(app_label, model_name)
-            
+
             # Get field information
             fields = []
             for field in model._meta.fields:
@@ -205,7 +206,7 @@ class DjangoToolset(AbstractToolset[DjangoDeps]):
                     'blank': field.blank,
                     'help_text': field.help_text,
                 })
-            
+
             return {
                 'app_label': model._meta.app_label,
                 'model_name': model._meta.model_name,