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

django_cfg/modules/django_admin/management/commands/tree.py

@@ -4,20 +4,16 @@
 Display Django project structure in a tree format based on configuration.
 """
 
-import os
 import subprocess
 from pathlib import Path
-from typing import List, Optional
 
-from django.core.management.base import BaseCommand, CommandError
 from django.conf import settings
-from django_cfg.modules.django_logging import get_logger
-
+from django.core.management.base import BaseCommand, CommandError
 
 from django_cfg.core.state import get_current_config
+from django_cfg.modules.django_logging import get_logger
 from django_cfg.utils.path_resolution import PathResolver
 
-
 logger = get_logger('tree')
 
 class Command(BaseCommand):
@@ -29,7 +25,7 @@ class Command(BaseCommand):
     is_destructive = False
 
     help = "Display Django project structure based on django-cfg configuration"
-    
+
     def add_arguments(self, parser):
         """Add command arguments."""
         parser.add_argument(
@@ -65,7 +61,7 @@ class Command(BaseCommand):
         )
         parser.add_argument(
             '--include-docker',
-            action='store_true', 
+            action='store_true',
             help='Include Docker configuration and volumes'
         )
         parser.add_argument(
@@ -84,21 +80,21 @@ class Command(BaseCommand):
             default='tree',
             help='Output format (default: tree)'
         )
-    
+
     def handle(self, *args, **options):
         """Execute the command."""
         logger.info("Starting tree command")
         try:
             # Get django-cfg configuration
             config = get_current_config()
-            
+
             # Determine base directory
             base_dir = self.get_base_directory(config)
-            
+
             self.stdout.write(
                 self.style.SUCCESS(f"📁 Django Project Structure: {base_dir}")
             )
-            
+
             # Try to get environment info
             try:
                 env_info = getattr(config, 'env_mode', 'unknown')
@@ -107,9 +103,9 @@ class Command(BaseCommand):
                 )
             except Exception:
                 pass
-                
+
             self.stdout.write("")
-            
+
             # Check if tree command is available
             if not self.is_tree_available():
                 self.stdout.write(
@@ -118,10 +114,10 @@ class Command(BaseCommand):
                 self.display_fallback_tree(base_dir, options)
             else:
                 self.display_tree(base_dir, options)
-                
+
         except Exception as e:
             raise CommandError(f"Failed to display project tree: {e}")
-    
+
     def get_base_directory(self, config) -> Path:
         """Get the base directory for the Django project tree."""
         try:
@@ -132,35 +128,35 @@ class Command(BaseCommand):
                 # Try to get from config
                 if hasattr(config, 'base_dir') and config.base_dir:
                     return Path(config.base_dir)
-                
+
                 # Fallback to Django BASE_DIR
                 if hasattr(settings, 'BASE_DIR'):
                     return Path(settings.BASE_DIR)
-                
+
                 # Last resort: current working directory
                 return Path.cwd()
-                
+
             except Exception as e:
                 self.stdout.write(
                     self.style.WARNING(f"Could not determine base directory: {e}")
                 )
                 return Path.cwd()
-    
+
     def is_tree_available(self) -> bool:
         """Check if tree command is available."""
         try:
-            subprocess.run(['tree', '--version'], 
-                         capture_output=True, 
+            subprocess.run(['tree', '--version'],
+                         capture_output=True,
                          check=True)
             return True
         except (subprocess.CalledProcessError, FileNotFoundError):
             return False
-    
+
     def build_ignore_pattern(self, options) -> str:
         """Build ignore pattern for tree command."""
         if options['no_ignore']:
             return ""
-        
+
         # Default ignore patterns
         default_ignores = [
             'node_modules',
@@ -190,69 +186,69 @@ class Command(BaseCommand):
             'django_cfg',
             # Package manager files
             'package-lock.json',
-            'pnpm-lock.yaml', 
+            'pnpm-lock.yaml',
             'poetry.lock',
             'yarn.lock',
             # Empty/system directories
             'db',
             'static'
         ]
-        
+
         # Conditionally add patterns based on options
         # Note: @docs folders are now included by default to show documentation
-            
+
         if not options.get('include_docker'):
             default_ignores.extend([
                 'docker',
                 'devops'
             ])
-            
+
         if not options.get('include_logs'):
             default_ignores.extend([
                 'logs',
                 '*.log',
                 'log'
             ])
-        
+
         # Add custom ignores
         if options['custom_ignore']:
             custom_ignores = options['custom_ignore'].split('|')
             default_ignores.extend(custom_ignores)
-        
+
         return '|'.join(default_ignores)
-    
+
     def display_tree(self, base_dir: Path, options):
         """Display tree using system tree command."""
         try:
             # Build tree command
             cmd = ['tree']
-            
+
             # Add ignore pattern
             ignore_pattern = self.build_ignore_pattern(options)
             if ignore_pattern:
                 cmd.extend(['-I', ignore_pattern])
-            
+
             # Add options
             cmd.append('--dirsfirst')  # Directories first
-            
+
             if options['depth']:
                 cmd.extend(['-L', str(options['depth'])])
-            
+
             if options['dirs_only']:
                 cmd.append('-d')
-            
+
             if options['all']:
                 cmd.append('-a')
-            
+
             # Add format options
             if options['format'] == 'json':
                 cmd.append('-J')
             elif options['format'] == 'xml':
                 cmd.append('-X')
-            
+
             # Add base directory
             cmd.append(str(base_dir))
-            
+
             # Execute command
             if options['output']:
                 with open(options['output'], 'w') as f:
@@ -271,20 +267,20 @@ class Command(BaseCommand):
                     self.stdout.write(
                         self.style.ERROR("❌ Tree command failed")
                     )
-                    
+
         except Exception as e:
             self.stdout.write(
                 self.style.ERROR(f"❌ Failed to execute tree command: {e}")
             )
             self.display_fallback_tree(base_dir, options)
-    
+
     def display_fallback_tree(self, base_dir: Path, options):
         """Fallback tree implementation using Python."""
         self.stdout.write("🐍 Using Python fallback implementation:")
         self.stdout.write("")
-        
+
         ignore_patterns = self.build_ignore_pattern(options).split('|') if not options['no_ignore'] else []
-        
+
         def should_ignore(path: Path) -> bool:
             """Check if path should be ignored."""
             name = path.name
@@ -298,12 +294,12 @@ class Command(BaseCommand):
                 elif pattern == name:
                     return True
             return False
-        
+
         def print_tree(directory: Path, prefix: str = "", depth: int = 0):
             """Recursively print directory tree."""
             if options['depth'] and depth >= options['depth']:
                 return
-            
+
             try:
                 items = []
                 for item in directory.iterdir():
@@ -312,14 +308,14 @@ class Command(BaseCommand):
                     if should_ignore(item):
                         continue
                     items.append(item)
-                
+
                 # Sort: directories first, then files
                 items.sort(key=lambda x: (not x.is_dir(), x.name.lower()))
-                
+
                 for i, item in enumerate(items):
                     is_last = i == len(items) - 1
                     current_prefix = "└── " if is_last else "├── "
-                    
+
                     if item.is_dir():
                         self.stdout.write(f"{prefix}{current_prefix}📁 {item.name}/")
                         if not options['dirs_only']:
@@ -329,16 +325,16 @@ class Command(BaseCommand):
                         # Add file type emoji
                         emoji = self.get_file_emoji(item)
                         self.stdout.write(f"{prefix}{current_prefix}{emoji} {item.name}")
-                        
+
             except PermissionError:
                 self.stdout.write(f"{prefix}❌ Permission denied")
-        
+
         print_tree(base_dir)
-    
+
     def get_file_emoji(self, file_path: Path) -> str:
         """Get emoji for file type."""
         suffix = file_path.suffix.lower()
-        
+
         emoji_map = {
             '.py': '🐍',
             '.js': '📜',
@@ -381,10 +377,10 @@ class Command(BaseCommand):
             'Pipfile': '📦',
             'Pipfile.lock': '🔒',
         }
-        
+
         # Check full filename first
         if file_path.name in emoji_map:
             return emoji_map[file_path.name]
-        
+
         # Then check extension
         return emoji_map.get(suffix, '📄')

django_cfg/modules/django_admin/mixins/display_mixin.py

@@ -2,41 +2,42 @@
 Display mixin for convenient wrapper methods.
 """
 
-from typing import Optional, Any
+from typing import Any, Optional
+
 from django.utils.safestring import SafeString
 
-from ..utils.displays import UserDisplay, MoneyDisplay, StatusDisplay, DateTimeDisplay
-from ..utils.badges import StatusBadge, CounterBadge
-from ..models.display_models import UserDisplayConfig, MoneyDisplayConfig, DateTimeDisplayConfig
 from ..models.badge_models import StatusBadgeConfig
+from ..models.display_models import DateTimeDisplayConfig, MoneyDisplayConfig, UserDisplayConfig
+from ..utils.badges import CounterBadge, StatusBadge
+from ..utils.displays import DateTimeDisplay, MoneyDisplay, UserDisplay
 
 
 class DisplayMixin:
     """Mixin for Django ModelAdmin classes with convenient display methods."""
-    
+
     def display_user_with_avatar(self, obj: Any, user_field: str = 'user',
                                 config: Optional[UserDisplayConfig] = None) -> list:
         """Display user with avatar for @display(header=True)."""
         user = getattr(obj, user_field, None)
         return UserDisplay.with_avatar(user, config)
-    
+
     def display_user_simple(self, obj: Any, user_field: str = 'user',
                            config: Optional[UserDisplayConfig] = None) -> SafeString:
         """Simple user display."""
         user = getattr(obj, user_field, None)
         return UserDisplay.simple(user, config)
-    
+
     def display_money_amount(self, obj: Any, amount_field: str,
                             config: Optional[MoneyDisplayConfig] = None) -> SafeString:
         """Display money amount."""
         amount = getattr(obj, amount_field, None)
         return MoneyDisplay.amount(amount, config)
-    
+
     def display_money_breakdown(self, obj: Any, main_field: str, breakdown_fields: dict,
                                config: Optional[MoneyDisplayConfig] = None) -> SafeString:
         """Display money with breakdown."""
         main_amount = getattr(obj, main_field, 0)
-        
+
         breakdown_items = []
         for label, field_name in breakdown_fields.items():
             amount = getattr(obj, field_name, 0)
@@ -45,32 +46,32 @@ class DisplayMixin:
                 'amount': amount,
                 'color': 'warning' if amount > 0 else 'secondary'
             })
-        
+
         return MoneyDisplay.with_breakdown(main_amount, breakdown_items, config)
-    
+
     def display_status_auto(self, obj: Any, status_field: str = 'status',
                            config: Optional[StatusBadgeConfig] = None) -> SafeString:
         """Display status with auto color mapping."""
         status = getattr(obj, status_field, '')
         return StatusBadge.auto(status, config)
-    
+
     def display_datetime_relative(self, obj: Any, datetime_field: str,
                                  config: Optional[DateTimeDisplayConfig] = None) -> SafeString:
         """Display datetime with relative time."""
         dt = getattr(obj, datetime_field, None)
         return DateTimeDisplay.relative(dt, config)
-    
+
     def display_datetime_compact(self, obj: Any, datetime_field: str,
                                 config: Optional[DateTimeDisplayConfig] = None) -> SafeString:
         """Display datetime compact."""
         dt = getattr(obj, datetime_field, None)
         return DateTimeDisplay.compact(dt, config)
-    
+
     def display_count_simple(self, obj: Any, count_field: str, label: str = None) -> SafeString:
         """Display count as badge."""
         count = getattr(obj, count_field, 0)
         return CounterBadge.simple(count, label)
-    
+
     def display_related_count(self, obj: Any, related_name: str, label: str = None) -> SafeString:
         """Display count of related objects."""
         try:

django_cfg/modules/django_admin/mixins/optimization_mixin.py

@@ -3,7 +3,8 @@ Query optimization mixin for performance.
 """
 
 import logging
-from typing import List, Dict, Any
+from typing import Any, Dict, List
+
 from django.contrib import admin
 from django.db.models import QuerySet
 
@@ -12,30 +13,30 @@ logger = logging.getLogger(__name__)
 
 class OptimizedModelAdmin(admin.ModelAdmin):
     """Optimized ModelAdmin with automatic query optimization."""
-    
+
     # Performance settings
     list_per_page = 50
     show_full_result_count = False
-    
+
     # Fields for optimization - override in subclasses
     select_related_fields: List[str] = []
     prefetch_related_fields: List[str] = []
     annotations: Dict[str, Any] = {}
-    
+
     def get_queryset(self, request) -> QuerySet:
         """Optimize queryset with select_related and prefetch_related."""
         qs = super().get_queryset(request)
-        
+
         if self.select_related_fields:
             qs = qs.select_related(*self.select_related_fields)
             logger.debug(f"Applied select_related: {self.select_related_fields}")
-        
+
         if self.prefetch_related_fields:
             qs = qs.prefetch_related(*self.prefetch_related_fields)
             logger.debug(f"Applied prefetch_related: {self.prefetch_related_fields}")
-        
+
         if self.annotations:
             qs = qs.annotate(**self.annotations)
             logger.debug(f"Applied annotations: {list(self.annotations.keys())}")
-        
+
         return qs

django_cfg/modules/django_admin/mixins/standalone_actions_mixin.py

@@ -5,18 +5,19 @@ Provides convenient decorators and utilities for creating standalone action butt
 that work independently of selected items (not bulk actions).
 """
 
-from typing import Callable, Optional, Any
+import threading
 from functools import wraps
+from typing import Any, Callable, Optional
+
 from django.contrib import messages
-from django.shortcuts import redirect
 from django.http import HttpResponse
-import threading
-
+from django.shortcuts import redirect
 from unfold.decorators import action as unfold_action
 from unfold.enums import ActionVariant as UnfoldActionVariant
+
 from django_cfg.modules.django_logging import get_logger
-from ..models.action_models import ActionVariant
 
+from ..models.action_models import ActionVariant
 
 logger = get_logger("django_admin.mixins.standalone_actions")
 
@@ -68,30 +69,30 @@ def standalone_action(
                             logger.info(f"Background action {func.__name__} completed: {result}")
                         except Exception as e:
                             logger.error(f"Background action {func.__name__} failed: {e}")
-                    
+
                     thread = threading.Thread(target=background_task)
                     thread.daemon = True
                     thread.start()
-                    
+
                     # Show immediate success message
                     if success_message:
                         messages.success(request, success_message)
                     else:
                         messages.success(request, f"{description} started in background.")
-                        
+
                 else:
                     # Run synchronously
                     result = func(self, request)
-                    
+
                     # Show success message
                     if success_message:
                         msg = success_message.format(result=result) if result else success_message
                         messages.success(request, msg)
                     else:
                         messages.success(request, f"{description} completed successfully.")
-                
+
                 logger.info(f"Standalone action {func.__name__} executed by {request.user.username}")
-                
+
             except Exception as e:
                 # Show error message
                 if error_message:
@@ -99,12 +100,12 @@ def standalone_action(
                     messages.error(request, msg)
                 else:
                     messages.error(request, f"❌ {description} failed: {str(e)}")
-                
+
                 logger.error(f"Standalone action {func.__name__} failed: {e}")
-            
+
             # Always redirect back
             return redirect(request.META.get('HTTP_REFERER', '/admin/'))
-        
+
         # Convert ActionVariant to UnfoldActionVariant
         unfold_variant = UnfoldActionVariant.DEFAULT
         if variant:
@@ -117,10 +118,10 @@ def standalone_action(
                 ActionVariant.DANGER: UnfoldActionVariant.DANGER,
             }
             unfold_variant = variant_mapping.get(variant, UnfoldActionVariant.DEFAULT)
-        
+
         # Auto-generate url_path if not provided
         final_url_path = url_path or func.__name__.replace('_', '-')
-        
+
         # Apply unfold decorator
         decorator_kwargs = {
             'description': description,
@@ -129,9 +130,9 @@ def standalone_action(
         }
         if icon:
             decorator_kwargs['icon'] = icon
-        
+
         return unfold_action(**decorator_kwargs)(wrapper)
-    
+
     return decorator
 
 
@@ -153,11 +154,11 @@ class StandaloneActionsMixin:
                 # Your update logic
                 return "Data updated"
     """
-    
+
     def get_standalone_actions(self):
         """Get list of standalone action method names."""
         return getattr(self, 'actions_list', [])
-    
+
     def execute_background_task(self, task_func: Callable, *args, **kwargs):
         """
         Utility method to execute tasks in background.
@@ -174,12 +175,12 @@ class StandaloneActionsMixin:
             except Exception as e:
                 logger.error(f"Background task {task_func.__name__} failed: {e}")
                 raise
-        
+
         thread = threading.Thread(target=background_task)
         thread.daemon = True
         thread.start()
         return thread
-    
+
     def send_admin_notification(self, request, message: str, level: str = 'INFO'):
         """
         Send notification to admin user.
@@ -195,8 +196,8 @@ class StandaloneActionsMixin:
             'WARNING': messages.WARNING,
             'ERROR': messages.ERROR,
         }
-        
+
         django_level = level_mapping.get(level.upper(), messages.INFO)
         messages.add_message(request, django_level, message)
-        
+
         logger.info(f"Admin notification sent to {request.user.username}: {message}")

django_cfg/modules/django_admin/models/__init__.py

@@ -2,15 +2,15 @@
 Pydantic 2 models for configuration.
 """
 
-from .base import BaseConfig
-from .display_models import UserDisplayConfig, MoneyDisplayConfig, DateTimeDisplayConfig
+from .action_models import ActionConfig, ActionVariant
 from .badge_models import BadgeConfig, BadgeVariant, StatusBadgeConfig
-from .action_models import ActionVariant, ActionConfig
+from .base import BaseConfig
+from .display_models import DateTimeDisplayConfig, MoneyDisplayConfig, UserDisplayConfig
 
 __all__ = [
     "BaseConfig",
     "UserDisplayConfig",
-    "MoneyDisplayConfig", 
+    "MoneyDisplayConfig",
     "DateTimeDisplayConfig",
     "BadgeConfig",
     "BadgeVariant",

django_cfg/modules/django_admin/models/action_models.py

@@ -3,8 +3,10 @@ Action configuration models.
 """
 
 from enum import Enum
+from typing import List, Optional
+
 from pydantic import Field
-from typing import Optional, List
+
 from .base import BaseConfig
 
 

django_cfg/modules/django_admin/models/badge_models.py

@@ -2,9 +2,11 @@
 Badge configuration models.
 """
 
+from typing import Dict, Optional
+
 from pydantic import Field
-from typing import Optional, Dict
-from .base import BaseConfig, BadgeVariant
+
+from .base import BadgeVariant, BaseConfig
 
 
 class BadgeConfig(BaseConfig):

django_cfg/modules/django_admin/models/base.py

@@ -2,15 +2,15 @@
 Base Pydantic 2 models.
 """
 
-from pydantic import BaseModel, Field, ConfigDict
-from typing import List
 from enum import Enum
 
+from pydantic import BaseModel, ConfigDict, Field
+
 
 class BaseConfig(BaseModel):
     """Base configuration for all utilities."""
     model_config = ConfigDict(validate_assignment=True, extra="forbid")
-    
+
     cache_timeout: int = Field(default=300, ge=0, le=3600)
     enable_icons: bool = Field(default=True)
     debug_mode: bool = Field(default=False)

django_cfg/modules/django_admin/models/display_models.py

@@ -3,6 +3,7 @@ Display configuration models.
 """
 
 from pydantic import Field
+
 from .base import BaseConfig