django-cfg 1.3.5__py3-none-any.whl → 1.3.9__py3-none-any.whl

django_cfg/management/commands/migrator.py

@@ -125,6 +125,11 @@ class Command(BaseCommand):
         except Exception as e:
             self.stdout.write(self.style.WARNING(f"⚠️  Warning creating migrations: {e}"))
 
+    def _raise_system_exit(self, message):
+        self.stdout.write(self.style.ERROR(f"❌ {message}"))
+        logger.error(message)
+        # raise SystemExit(1)
+
     def migrate_database(self, db_name):
         """Migrate specific database"""
         try:
@@ -154,12 +159,12 @@ class Command(BaseCommand):
                     self.stdout.write(f"  📦 Migrating {app}...")
                     call_command("migrate", app, database=db_name, verbosity=1)
                 except Exception as e:
-                    self.stdout.write(self.style.WARNING(f"  ⚠️  Warning migrating {app}: {e}"))
+                    self._raise_system_exit(f"Migration failed for {app} on {db_name}: {e}")
 
             self.stdout.write(self.style.SUCCESS(f"✅ {db_name} migration completed!"))
 
         except Exception as e:
-            self.stdout.write(self.style.ERROR(f"❌ Error migrating {db_name}: {e}"))
+            self._raise_system_exit(f"Error migrating {db_name}: {e}")
 
     def migrate_constance_if_needed(self):
         """Always migrate constance app if it's installed"""
@@ -173,12 +178,12 @@ class Command(BaseCommand):
                     call_command("migrate", "constance", database="default", verbosity=1)
                     self.stdout.write(self.style.SUCCESS("✅ Constance migration completed!"))
                 except Exception as e:
-                    self.stdout.write(self.style.WARNING(f"⚠️  Constance migration warning: {e}"))
+                    self._raise_system_exit(f"Constance migration failed: {e}")
             else:
                 self.stdout.write(self.style.WARNING("⚠️  Constance not found in INSTALLED_APPS"))
                 
         except Exception as e:
-            self.stdout.write(self.style.WARNING(f"⚠️  Could not migrate constance: {e}"))
+            self._raise_system_exit(f"Could not migrate constance: {e}")
 
     def migrate_app(self, app_name):
         """Migrate specific app across all databases"""
@@ -192,7 +197,7 @@ class Command(BaseCommand):
                 try:
                     call_command("migrate", app_name, database=db_name, verbosity=1)
                 except Exception as e:
-                    self.stdout.write(self.style.WARNING(f"  ⚠️  Warning: {e}"))
+                    self._raise_system_exit(f"Migration failed for {app_name} on {db_name}: {e}")
 
     def show_database_status(self):
         """Show status of all databases and their apps"""
@@ -265,7 +270,7 @@ class Command(BaseCommand):
             self.stdout.write(f"📦 Installed Apps: {len(settings.INSTALLED_APPS)}")
 
         except Exception as e:
-            self.stdout.write(self.style.ERROR(f"❌ Error getting Django config info: {e}"))
+            self._raise_system_exit(f"Error getting Django config info: {e}")
 
     def get_apps_for_database(self, db_name: str):
         """Get apps for specific database with smart logic for default"""

django_cfg/management/commands/rundramatiq.py

@@ -16,8 +16,6 @@ from django.conf import settings
 from django.core.management.base import BaseCommand
 from django.utils.module_loading import module_has_submodule
 from django_cfg.modules.django_logger import get_logger
-
-
 from django_cfg.modules.django_tasks import get_task_service
 
 
@@ -111,8 +109,10 @@ class Command(BaseCommand):
         # If dry run, show command and exit
         if dry_run:
             executable_name = "dramatiq"
+            
             process_args = [
                 executable_name,
+                "django_cfg.modules.dramatiq_setup",  # Broker module
                 "--processes", str(processes),
                 "--threads", str(threads),
                 "--worker-shutdown-timeout", str(worker_shutdown_timeout),
@@ -150,6 +150,7 @@ class Command(BaseCommand):
         # Build process arguments exactly like django_dramatiq
         process_args = [
             executable_name,
+            "django_cfg.modules.dramatiq_setup",  # Broker module
             "--processes", str(processes),
             "--threads", str(threads),
             "--worker-shutdown-timeout", str(worker_shutdown_timeout),

django_cfg/middleware/__init__.py

@@ -5,9 +5,7 @@ Provides middleware components for Django CFG applications.
 """
 
 from .user_activity import UserActivityMiddleware
-from .static_nocache import StaticNoCacheMiddleware
 
 __all__ = [
     'UserActivityMiddleware',
-    'StaticNoCacheMiddleware',
 ]

django_cfg/models/api_keys.py

@@ -0,0 +1,115 @@
+"""
+API Keys configuration models for django-cfg.
+
+Simple model for OpenAI and OpenRouter API keys.
+Following CRITICAL_REQUIREMENTS.md:
+- No raw Dict/Any usage - everything through Pydantic models
+- Proper type annotations for all fields
+- No mutable default arguments
+"""
+
+from typing import Optional
+from pydantic import BaseModel, Field, field_validator, SecretStr
+
+
+class ApiKeys(BaseModel):
+    """
+    API keys configuration for LLM services.
+    
+    Simple model for storing OpenAI and OpenRouter API keys.
+    
+    Example:
+        ```python
+        api_keys = ApiKeys(
+            openai="${OPENAI_API_KEY}",
+            openrouter="${OPENROUTER_API_KEY}"
+        )
+        ```
+    """
+    
+    model_config = {
+        "validate_assignment": True,
+        "extra": "forbid",
+        "str_strip_whitespace": True,
+        "validate_default": True,
+    }
+    
+    # === LLM Provider Keys ===
+    openai: Optional[SecretStr] = Field(
+        default=None,
+        description="OpenAI API key for GPT models and embeddings"
+    )
+    
+    openrouter: Optional[SecretStr] = Field(
+        default=None,
+        description="OpenRouter API key for access to multiple LLM providers"
+    )
+    
+    @field_validator("openai")
+    @classmethod
+    def validate_openai_key(cls, v: Optional[SecretStr]) -> Optional[SecretStr]:
+        """Validate OpenAI API key format."""
+        if v is None:
+            return v
+        
+        key_str = v.get_secret_value()
+        if not key_str.startswith(("sk-", "sk-proj-")):
+            raise ValueError("OpenAI API key must start with 'sk-' or 'sk-proj-'")
+        
+        if len(key_str) < 20:
+            raise ValueError("OpenAI API key appears to be too short")
+        
+        return v
+    
+    @field_validator("openrouter")
+    @classmethod
+    def validate_openrouter_key(cls, v: Optional[SecretStr]) -> Optional[SecretStr]:
+        """Validate OpenRouter API key format."""
+        if v is None:
+            return v
+        
+        key_str = v.get_secret_value()
+        if not key_str.startswith(("sk-or-", "sk-proj-")):
+            raise ValueError("OpenRouter API key must start with 'sk-or-' or 'sk-proj-'")
+        
+        if len(key_str) < 20:
+            raise ValueError("OpenRouter API key appears to be too short")
+        
+        return v
+    
+    def get_openai_key(self) -> Optional[str]:
+        """Get OpenAI API key as string."""
+        return self.openai.get_secret_value() if self.openai else None
+    
+    def get_openrouter_key(self) -> Optional[str]:
+        """Get OpenRouter API key as string."""
+        return self.openrouter.get_secret_value() if self.openrouter else None
+    
+    def has_openai(self) -> bool:
+        """Check if OpenAI key is configured."""
+        return self.openai is not None
+    
+    def has_openrouter(self) -> bool:
+        """Check if OpenRouter key is configured."""
+        return self.openrouter is not None
+    
+    def get_preferred_provider(self) -> Optional[str]:
+        """
+        Get preferred provider based on availability.
+        
+        Priority: OpenRouter (default) > OpenAI
+        
+        Returns:
+            "openrouter" or "openai" or None
+        """
+        if self.has_openrouter():
+            return "openrouter"
+        elif self.has_openai():
+            return "openai"
+        return None
+
+
+# Export the main class
+__all__ = [
+    "ApiKeys",
+]

django_cfg/modules/django_admin/__init__.py

@@ -0,0 +1,64 @@
+"""
+Django Admin Utilities - Universal HTML Builder System
+
+Clean, type-safe admin utilities with no HTML duplication.
+"""
+
+# Core utilities
+from .utils.displays import UserDisplay, MoneyDisplay, StatusDisplay, DateTimeDisplay
+from .utils.badges import StatusBadge, ProgressBadge, CounterBadge
+
+# Icons
+from .icons import Icons, IconCategories
+
+# Admin mixins
+from .mixins.display_mixin import DisplayMixin
+from .mixins.optimization_mixin import OptimizedModelAdmin
+from .mixins.standalone_actions_mixin import StandaloneActionsMixin, standalone_action
+
+# Configuration models
+from .models.display_models import UserDisplayConfig, MoneyDisplayConfig, DateTimeDisplayConfig
+from .models.badge_models import BadgeConfig, BadgeVariant, StatusBadgeConfig
+from .models.action_models import ActionVariant, ActionConfig
+
+# Decorators
+from .decorators import display, action
+
+__version__ = "1.0.0"
+
+__all__ = [
+    # Display utilities
+    "UserDisplay",
+    "MoneyDisplay", 
+    "StatusDisplay",
+    "DateTimeDisplay",
+    
+    # Badge utilities
+    "StatusBadge",
+    "ProgressBadge",
+    "CounterBadge",
+    
+    # Icons
+    "Icons",
+    "IconCategories",
+    
+    # Admin mixins
+    "OptimizedModelAdmin",
+    "DisplayMixin",
+    "StandaloneActionsMixin",
+    "standalone_action",
+    
+    # Configuration models
+    "UserDisplayConfig",
+    "MoneyDisplayConfig",
+    "DateTimeDisplayConfig",
+    "BadgeConfig",
+    "BadgeVariant",
+    "StatusBadgeConfig",
+    "ActionVariant",
+    "ActionConfig",
+    
+    # Decorators
+    "display",
+    "action",
+]

django_cfg/modules/django_admin/decorators/__init__.py

@@ -0,0 +1,13 @@
+"""
+Django Admin Decorators - Wrappers for Unfold decorators.
+
+Provides consistent, type-safe decorators with our admin utilities integration.
+"""
+
+from .display import display
+from .actions import action
+
+__all__ = [
+    'display',
+    'action',
+]

django_cfg/modules/django_admin/decorators/actions.py

@@ -0,0 +1,106 @@
+"""
+Action decorator wrapper for Unfold integration.
+
+Provides type-safe action decorators with consistent styling.
+"""
+
+from typing import Optional, Callable, Any
+from functools import wraps
+from unfold.decorators import action as unfold_action
+from unfold.enums import ActionVariant as UnfoldActionVariant
+
+from django_cfg.modules.django_logger import get_logger
+from ..models.action_models import ActionVariant
+
+
+logger = get_logger("django_admin.decorators.actions")
+
+def action(
+    description: str,
+    variant: Optional[ActionVariant] = None,
+    icon: Optional[str] = None,
+    permissions: Optional[list] = None,
+    url_path: Optional[str] = None,
+    attrs: Optional[dict] = None
+) -> Callable:
+    """
+    Enhanced action decorator with Django Admin Utilities integration.
+    
+    Args:
+        description: Action description shown in admin
+        variant: Action style variant (ActionVariant enum)
+        icon: Material icon name
+        permissions: Required permissions list
+        url_path: URL path for standalone action buttons (creates separate button)
+        attrs: Additional attributes for the action
+    
+    Usage:
+        # Bulk action (works on selected items)
+        @action(description="Activate items", variant=ActionVariant.SUCCESS)
+        def activate_items(self, request, queryset):
+            updated = queryset.update(is_active=True)
+            self.message_user(request, f"Activated {updated} items.")
+        
+        # Standalone action button (url_path creates separate button)
+        @action(
+            description="Update Rates",
+            variant=ActionVariant.SUCCESS,
+            url_path="update-rates",
+            icon="sync"
+        )
+        def update_rates(self, request):
+            # Standalone action logic (no queryset parameter)
+            pass
+    """
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(self, request: Any, *args, **kwargs) -> Any:
+            try:
+                # For url_path actions, there's no queryset parameter
+                if url_path:
+                    return func(self, request, *args, **kwargs)
+                else:
+                    # For bulk actions, pass queryset as second parameter
+                    queryset = args[0] if args else kwargs.get('queryset')
+                    return func(self, request, queryset, *args[1:], **kwargs)
+            except Exception as e:
+                # Log error and show user message
+                logger.error(f"Error in action {func.__name__}: {e}")
+                
+                self.message_user(
+                    request,
+                    f"Error executing action: {str(e)}",
+                    level='ERROR'
+                )
+        
+        # Convert our ActionVariant to Unfold ActionVariant
+        action_variant = None
+        if variant:
+            # Direct mapping since values are the same
+            unfold_variant_mapping = {
+                ActionVariant.DEFAULT: UnfoldActionVariant.DEFAULT,
+                ActionVariant.PRIMARY: UnfoldActionVariant.PRIMARY,
+                ActionVariant.SUCCESS: UnfoldActionVariant.SUCCESS,
+                ActionVariant.INFO: UnfoldActionVariant.INFO,
+                ActionVariant.WARNING: UnfoldActionVariant.WARNING,
+                ActionVariant.DANGER: UnfoldActionVariant.DANGER,
+            }
+            action_variant = unfold_variant_mapping.get(variant, UnfoldActionVariant.DEFAULT)
+        
+        # Build decorator kwargs
+        decorator_kwargs = {'description': description}
+        if action_variant:
+            decorator_kwargs['variant'] = action_variant
+        if icon:
+            decorator_kwargs['icon'] = icon
+        if permissions:
+            decorator_kwargs['permissions'] = permissions
+        if url_path:
+            decorator_kwargs['url_path'] = url_path
+        if attrs:
+            decorator_kwargs['attrs'] = attrs
+        
+        # Apply Unfold decorator
+        return unfold_action(**decorator_kwargs)(wrapper)
+    
+    return decorator

django_cfg/modules/django_admin/decorators/display.py

@@ -0,0 +1,106 @@
+"""
+Display decorator wrapper for Unfold integration.
+
+Provides type-safe display decorators with our admin utilities.
+"""
+
+from typing import Optional, Callable, Any, Union
+from functools import wraps
+from django.utils.safestring import SafeString, mark_safe
+from unfold.decorators import display as unfold_display
+from django_cfg.modules.django_logger import get_logger
+
+logger = get_logger('django_admin.decorators.display')
+
+def display(
+    function: Optional[Callable] = None,
+    *,
+    boolean: Optional[bool] = None,
+    image: Optional[bool] = None,
+    ordering: Optional[str] = None,
+    description: Optional[str] = None,
+    empty_value: Optional[str] = None,
+    dropdown: Optional[bool] = None,
+    label: Union[bool, str, dict, None] = None,
+    header: Optional[bool] = None
+) -> Callable:
+    """
+    Enhanced display decorator with Django Admin Utilities integration.
+    
+    This decorator wraps unfold.decorators.display with additional features:
+    - Automatic HTML safety detection and marking
+    - Empty value handling with customizable fallback
+    - Error handling with logging
+    
+    Args:
+        function: Function to decorate (for direct usage)
+        boolean: Show as boolean icon (True/False icons)
+        image: Show as image thumbnail
+        ordering: Field name for sorting
+        description: Column header text
+        empty_value: Default value for empty/None fields
+        dropdown: Show as dropdown menu
+        label: Show as label badge (bool, str, or dict for styling)
+        header: Show as header with avatar
+    
+    Usage:
+        @display(description="User", header=True)
+        def user_display(self, obj):
+            return self.display_user_with_avatar(obj, 'user')
+        
+        @display(description="Status", label=True)
+        def status_display(self, obj):
+            return self.display_status_auto(obj, 'status')
+            
+        @display(description="Has Embedding", boolean=True)
+        def has_embedding_display(self, obj):
+            return obj.has_embedding
+            
+        @display(description="Avatar", image=True)
+        def avatar_display(self, obj):
+            return obj.avatar.url if obj.avatar else None
+    """
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(self, obj: Any) -> Any:
+            try:
+                result = func(self, obj)
+                
+                # Handle empty values (use our default if unfold's empty_value is None)
+                if result is None or result == "":
+                    return empty_value if empty_value is not None else "—"
+                
+                # Auto-mark HTML as safe if it contains HTML tags
+                if isinstance(result, str) and ('<' in result and '>' in result):
+                    return mark_safe(result)
+                
+                # SafeString is already safe
+                if isinstance(result, SafeString):
+                    return result
+                
+                return result
+            except Exception as e:
+                # Log error and return safe fallback
+                logger.error(f"Error in display method {func.__name__}: {e}")
+                return empty_value if empty_value is not None else "—"
+        
+        # Apply Unfold decorator with all parameters
+        return unfold_display(
+            function=None,  # We handle the function ourselves
+            boolean=boolean,
+            image=image,
+            ordering=ordering,
+            description=description,
+            empty_value=empty_value,
+            dropdown=dropdown,
+            label=label,
+            header=header
+        )(wrapper)
+    
+    # Support both @display and @display(...) usage
+    if function is not None:
+        # Direct usage: @display
+        return decorator(function)
+    else:
+        # Parametrized usage: @display(...)
+        return decorator

django_cfg/modules/django_admin/mixins/__init__.py

@@ -0,0 +1,14 @@
+"""
+Admin mixins for easy integration.
+"""
+
+from .display_mixin import DisplayMixin
+from .optimization_mixin import OptimizedModelAdmin
+from .standalone_actions_mixin import StandaloneActionsMixin, standalone_action
+
+__all__ = [
+    "DisplayMixin",
+    "OptimizedModelAdmin",
+    "StandaloneActionsMixin",
+    "standalone_action",
+]

django_cfg/modules/django_admin/mixins/display_mixin.py

@@ -0,0 +1,81 @@
+"""
+Display mixin for convenient wrapper methods.
+"""
+
+from typing import Optional, Any
+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
+
+
+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)
+            breakdown_items.append({
+                'label': label,
+                '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:
+            related_manager = getattr(obj, related_name)
+            count = related_manager.count()
+            return CounterBadge.simple(count, label)
+        except AttributeError:
+            return CounterBadge.simple(0, label)

django_cfg/modules/django_admin/mixins/optimization_mixin.py

@@ -0,0 +1,41 @@
+"""
+Query optimization mixin for performance.
+"""
+
+import logging
+from typing import List, Dict, Any
+from django.contrib import admin
+from django.db.models import QuerySet
+
+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