django-cfg 1.1.82__py3-none-any.whl → 1.2.1__py3-none-any.whl

django_cfg/apps/agents/toolsets/django_toolset.py

@@ -0,0 +1,220 @@
+"""
+Core Django toolset with common Django operations.
+"""
+
+import logging
+from typing import Dict, Any, List, Optional
+from pydantic_ai.toolsets import AbstractToolset
+from pydantic_ai import RunContext
+
+from ..core.dependencies import DjangoDeps
+
+logger = logging.getLogger(__name__)
+
+
+class DjangoToolset(AbstractToolset[DjangoDeps]):
+    """
+    Core Django toolset providing common Django operations.
+    
+    Includes tools for:
+    - User management
+    - Session handling
+    - 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,
+            'email': user.email,
+            'first_name': user.first_name,
+            'last_name': user.last_name,
+            'is_active': user.is_active,
+            'is_staff': user.is_staff,
+            'is_superuser': user.is_superuser,
+            '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:
+            group_perms = await group.permissions.aall()
+            async for perm in group_perms:
+                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, 
+        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)
+        elif level.lower() == 'info':
+            logger.info(message, extra=log_data)
+        elif level.lower() == 'warning':
+            logger.warning(message, extra=log_data)
+        elif level.lower() == 'error':
+            logger.error(message, extra=log_data)
+        elif level.lower() == 'critical':
+            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',
+            'TIME_ZONE',
+            'LANGUAGE_CODE',
+            'USE_TZ',
+            'USE_I18N',
+            'MEDIA_URL',
+            '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,
+                'verbose_name': app_config.verbose_name,
+                'path': str(app_config.path),
+                'models_module': app_config.models_module.__name__ if app_config.models_module else None,
+            }
+        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, 
+        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:
+                fields.append({
+                    'name': field.name,
+                    'type': field.__class__.__name__,
+                    'null': field.null,
+                    'blank': field.blank,
+                    'help_text': field.help_text,
+                })
+            
+            return {
+                'app_label': model._meta.app_label,
+                'model_name': model._meta.model_name,
+                'verbose_name': str(model._meta.verbose_name),
+                'verbose_name_plural': str(model._meta.verbose_name_plural),
+                'db_table': model._meta.db_table,
+                'fields': fields,
+                'field_count': len(fields),
+            }
+        except Exception as e:
+            logger.error(f"Failed to get model info for '{app_label}.{model_name}': {e}")
+            return {}

django_cfg/apps/agents/toolsets/file_toolset.py

@@ -0,0 +1,324 @@
+"""
+Django file toolset for file operations.
+"""
+
+import os
+import logging
+from pathlib import Path
+from typing import Dict, Any, List, Optional, Union
+from pydantic_ai.toolsets import AbstractToolset
+from pydantic_ai import RunContext
+from django.conf import settings
+from django.core.files.storage import default_storage
+from django.core.files.base import ContentFile
+
+from ..core.dependencies import DjangoDeps
+
+logger = logging.getLogger(__name__)
+
+
+class FileToolset(AbstractToolset[DjangoDeps]):
+    """
+    Django file toolset for safe file operations.
+    
+    Provides tools for:
+    - File reading/writing (within allowed directories)
+    - Media file handling
+    - Static file operations
+    - File metadata
+    """
+    
+    def __init__(self, allowed_paths: Optional[List[str]] = None, max_file_size: int = 10 * 1024 * 1024):
+        """
+        Initialize file toolset.
+        
+        Args:
+            allowed_paths: List of allowed directory paths (relative to MEDIA_ROOT)
+            max_file_size: Maximum file size in bytes (default: 10MB)
+        """
+        self.allowed_paths = allowed_paths or ['orchestrator', 'temp']
+        self.max_file_size = max_file_size
+    
+    @property
+    def id(self) -> str:
+        return "django_files"
+    
+    def _check_path_access(self, file_path: str) -> bool:
+        """Check if file path is within allowed directories."""
+        path = Path(file_path)
+        
+        # Normalize path and check if it's within allowed paths
+        try:
+            # Remove any parent directory traversal
+            normalized_path = path.resolve()
+            
+            # Check against allowed paths
+            for allowed_path in self.allowed_paths:
+                allowed_full_path = Path(settings.MEDIA_ROOT) / allowed_path
+                try:
+                    normalized_path.relative_to(allowed_full_path.resolve())
+                    return True
+                except ValueError:
+                    continue
+            
+            return False
+        except Exception:
+            return False
+    
+    def _get_safe_path(self, file_path: str, user_id: int) -> str:
+        """Get safe file path with user scoping."""
+        # Add user scoping to prevent access to other users' files
+        safe_path = f"orchestrator/user_{user_id}/{file_path}"
+        
+        # Normalize and validate
+        normalized = os.path.normpath(safe_path)
+        
+        # Ensure no directory traversal
+        if '..' in normalized or normalized.startswith('/'):
+            raise ValueError("Invalid file path")
+        
+        return normalized
+    
+    async def read_file(
+        self, 
+        ctx: RunContext[DjangoDeps], 
+        file_path: str,
+        encoding: str = 'utf-8'
+    ) -> Optional[str]:
+        """Read text file content."""
+        user_id = ctx.deps.user.id
+        safe_path = self._get_safe_path(file_path, user_id)
+        
+        try:
+            if default_storage.exists(safe_path):
+                with default_storage.open(safe_path, 'r') as f:
+                    content = f.read()
+                
+                logger.debug(f"Read file: {safe_path} ({len(content)} chars)")
+                return content
+            else:
+                logger.warning(f"File not found: {safe_path}")
+                return None
+        except Exception as e:
+            logger.error(f"Failed to read file '{safe_path}': {e}")
+            return None
+    
+    async def write_file(
+        self, 
+        ctx: RunContext[DjangoDeps], 
+        file_path: str,
+        content: str,
+        encoding: str = 'utf-8'
+    ) -> bool:
+        """Write text content to file."""
+        user_id = ctx.deps.user.id
+        safe_path = self._get_safe_path(file_path, user_id)
+        
+        # Check file size
+        content_bytes = content.encode(encoding)
+        if len(content_bytes) > self.max_file_size:
+            logger.error(f"File too large: {len(content_bytes)} bytes > {self.max_file_size}")
+            return False
+        
+        try:
+            # Create directory if needed
+            dir_path = os.path.dirname(safe_path)
+            if dir_path and not default_storage.exists(dir_path):
+                # Create directory structure
+                parts = dir_path.split('/')
+                current_path = ''
+                for part in parts:
+                    current_path = os.path.join(current_path, part) if current_path else part
+                    if not default_storage.exists(current_path):
+                        default_storage.save(f"{current_path}/.keep", ContentFile(b''))
+            
+            # Write file
+            default_storage.save(safe_path, ContentFile(content_bytes))
+            
+            logger.debug(f"Wrote file: {safe_path} ({len(content_bytes)} bytes)")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to write file '{safe_path}': {e}")
+            return False
+    
+    async def delete_file(self, ctx: RunContext[DjangoDeps], file_path: str) -> bool:
+        """Delete file."""
+        user_id = ctx.deps.user.id
+        safe_path = self._get_safe_path(file_path, user_id)
+        
+        try:
+            if default_storage.exists(safe_path):
+                default_storage.delete(safe_path)
+                logger.debug(f"Deleted file: {safe_path}")
+                return True
+            else:
+                logger.warning(f"File not found for deletion: {safe_path}")
+                return False
+        except Exception as e:
+            logger.error(f"Failed to delete file '{safe_path}': {e}")
+            return False
+    
+    async def list_files(
+        self, 
+        ctx: RunContext[DjangoDeps], 
+        directory_path: str = "",
+        pattern: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        """List files in directory."""
+        user_id = ctx.deps.user.id
+        safe_path = self._get_safe_path(directory_path, user_id)
+        
+        try:
+            if not default_storage.exists(safe_path):
+                return []
+            
+            # List directory contents
+            directories, files = default_storage.listdir(safe_path)
+            
+            results = []
+            
+            # Add directories
+            for directory in directories:
+                dir_path = os.path.join(safe_path, directory)
+                results.append({
+                    'name': directory,
+                    'type': 'directory',
+                    'path': dir_path,
+                    'size': None,
+                    'modified': None,
+                })
+            
+            # Add files
+            for file in files:
+                file_path = os.path.join(safe_path, file)
+                
+                # Apply pattern filter if specified
+                if pattern and pattern not in file:
+                    continue
+                
+                try:
+                    size = default_storage.size(file_path)
+                    modified = default_storage.get_modified_time(file_path)
+                    
+                    results.append({
+                        'name': file,
+                        'type': 'file',
+                        'path': file_path,
+                        'size': size,
+                        'modified': modified.isoformat() if modified else None,
+                    })
+                except Exception as e:
+                    logger.warning(f"Could not get file info for '{file_path}': {e}")
+                    results.append({
+                        'name': file,
+                        'type': 'file',
+                        'path': file_path,
+                        'size': None,
+                        'modified': None,
+                    })
+            
+            return results
+        except Exception as e:
+            logger.error(f"Failed to list files in '{safe_path}': {e}")
+            return []
+    
+    async def get_file_info(
+        self, 
+        ctx: RunContext[DjangoDeps], 
+        file_path: str
+    ) -> Optional[Dict[str, Any]]:
+        """Get file metadata."""
+        user_id = ctx.deps.user.id
+        safe_path = self._get_safe_path(file_path, user_id)
+        
+        try:
+            if not default_storage.exists(safe_path):
+                return None
+            
+            size = default_storage.size(safe_path)
+            modified = default_storage.get_modified_time(safe_path)
+            url = default_storage.url(safe_path) if hasattr(default_storage, 'url') else None
+            
+            return {
+                'path': safe_path,
+                'size': size,
+                'modified': modified.isoformat() if modified else None,
+                'url': url,
+                'exists': True,
+            }
+        except Exception as e:
+            logger.error(f"Failed to get file info for '{safe_path}': {e}")
+            return None
+    
+    async def copy_file(
+        self, 
+        ctx: RunContext[DjangoDeps], 
+        source_path: str,
+        destination_path: str
+    ) -> bool:
+        """Copy file to new location."""
+        user_id = ctx.deps.user.id
+        safe_source = self._get_safe_path(source_path, user_id)
+        safe_dest = self._get_safe_path(destination_path, user_id)
+        
+        try:
+            if not default_storage.exists(safe_source):
+                logger.error(f"Source file not found: {safe_source}")
+                return False
+            
+            # Read source file
+            with default_storage.open(safe_source, 'rb') as source_file:
+                content = source_file.read()
+            
+            # Check size limit
+            if len(content) > self.max_file_size:
+                logger.error(f"File too large to copy: {len(content)} bytes")
+                return False
+            
+            # Write to destination
+            default_storage.save(safe_dest, ContentFile(content))
+            
+            logger.debug(f"Copied file: {safe_source} -> {safe_dest}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to copy file '{safe_source}' to '{safe_dest}': {e}")
+            return False
+    
+    async def move_file(
+        self, 
+        ctx: RunContext[DjangoDeps], 
+        source_path: str,
+        destination_path: str
+    ) -> bool:
+        """Move file to new location."""
+        # Copy then delete
+        if await self.copy_file(ctx, source_path, destination_path):
+            return await self.delete_file(ctx, source_path)
+        return False
+    
+    async def get_storage_info(self, ctx: RunContext[DjangoDeps]) -> Dict[str, Any]:
+        """Get storage backend information."""
+        user_id = ctx.deps.user.id
+        user_dir = self._get_safe_path("", user_id)
+        
+        info = {
+            'storage_backend': default_storage.__class__.__name__,
+            'user_directory': user_dir,
+            'max_file_size': self.max_file_size,
+            'allowed_paths': self.allowed_paths,
+        }
+        
+        try:
+            # Try to get user directory size
+            files = await self.list_files(ctx, "")
+            total_size = sum(f.get('size', 0) or 0 for f in files if f['type'] == 'file')
+            file_count = sum(1 for f in files if f['type'] == 'file')
+            
+            info.update({
+                'user_files_count': file_count,
+                'user_total_size': total_size,
+            })
+        except Exception as e:
+            logger.warning(f"Could not get storage stats: {e}")
+        
+        return info