django-cfg 1.5.8__py3-none-any.whl → 1.5.14__py3-none-any.whl

django_cfg/apps/system/maintenance/management/commands/process_scheduled_maintenance.py

@@ -5,16 +5,18 @@ Handles automatic start/stop of scheduled maintenance windows.
 """
 
 
-from django.core.management.base import BaseCommand
 from django.utils import timezone
 
+from django_cfg.management.utils import AdminCommand
+
 from ...models import ScheduledMaintenance
 from ...services.scheduled_maintenance_service import scheduled_maintenance_service
 
 
-class Command(BaseCommand):
+class Command(AdminCommand):
     """Process scheduled maintenance events."""
 
+    command_name = 'process_scheduled_maintenance'
     help = 'Process scheduled maintenance events (start due, complete overdue)'
 
     def add_arguments(self, parser):

django_cfg/apps/system/maintenance/management/commands/sync_cloudflare.py

@@ -5,16 +5,19 @@ Automatically discovers and syncs Cloudflare zones with Django models.
 """
 
 
-from django.core.management.base import BaseCommand, CommandError
+from django.core.management.base import CommandError
 from django.utils import timezone
 
+from django_cfg.management.utils import AdminCommand
+
 from ...models import CloudflareApiKey
 from ...services.site_sync_service import SiteSyncService
 
 
-class Command(BaseCommand):
+class Command(AdminCommand):
     """Sync sites with Cloudflare zones."""
 
+    command_name = 'sync_cloudflare'
     help = 'Sync CloudflareSite models with actual Cloudflare zones'
 
     def add_arguments(self, parser):

django_cfg/config.py

@@ -9,6 +9,39 @@ from typing import List
 from .modules.django_admin.icons import Icons
 from .modules.django_unfold.models.dropdown import SiteDropdownItem
 
+
+def is_feature_available(feature: str) -> bool:
+    """
+    Check if a feature is available (dependencies installed).
+
+    Args:
+        feature: Feature name (e.g., 'grpc', 'centrifugo', 'dramatiq')
+
+    Returns:
+        True if feature dependencies are available
+    """
+    if feature == "grpc":
+        try:
+            import grpc  # noqa
+            import grpc_reflection  # noqa
+            return True
+        except ImportError:
+            return False
+    elif feature == "centrifugo":
+        try:
+            import cent  # noqa
+            return True
+        except ImportError:
+            return False
+    elif feature == "dramatiq":
+        try:
+            import dramatiq  # noqa
+            return True
+        except ImportError:
+            return False
+
+    return False
+
 # Library configuration
 LIB_NAME = "django-cfg"
 LIB_SITE_URL = "https://djangocfg.com"

django_cfg/core/generation/integration_generators/grpc_generator.py

@@ -119,9 +119,10 @@ class GRPCSettingsGenerator:
         if grpc_proto:
             settings["GRPC_PROTO"] = grpc_proto
 
-        logger.info("✅ gRPC framework enabled")
+        logger.info("✅ gRPC framework enabled (async)")
         logger.info(f"   - Server: {self.config.grpc.server.host}:{self.config.grpc.server.port}")
-        logger.info(f"   - Workers: {self.config.grpc.server.max_workers}")
+        max_streams = self.config.grpc.server.max_concurrent_streams or "unlimited"
+        logger.info(f"   - Max concurrent streams: {max_streams}")
         logger.info(f"   - Auth: {'enabled' if self.config.grpc.auth.enabled else 'disabled'}")
         logger.info(f"   - Reflection: {'enabled' if self.config.grpc.server.enable_reflection else 'disabled'}")
 
@@ -169,7 +170,8 @@ class GRPCSettingsGenerator:
         server_settings = {
             "host": server_config.host,
             "port": server_config.port,
-            "max_workers": server_config.max_workers,
+            "max_concurrent_streams": server_config.max_concurrent_streams,
+            "asyncio_debug": server_config.asyncio_debug,
             "enable_reflection": server_config.enable_reflection,
             "enable_health_check": server_config.enable_health_check,
             "max_send_message_length": server_config.max_send_message_length,
@@ -200,21 +202,11 @@ class GRPCSettingsGenerator:
         auth_settings = {
             "enabled": auth_config.enabled,
             "require_auth": auth_config.require_auth,
-            "token_header": auth_config.token_header,
-            "token_prefix": auth_config.token_prefix,
-            "jwt_algorithm": auth_config.jwt_algorithm,
-            "jwt_verify_exp": auth_config.jwt_verify_exp,
-            "jwt_leeway": auth_config.jwt_leeway,
+            "api_key_header": auth_config.api_key_header,
+            "accept_django_secret_key": auth_config.accept_django_secret_key,
             "public_methods": auth_config.public_methods,
         }
 
-        # Use JWT secret from auth config or fall back to Django SECRET_KEY
-        if auth_config.jwt_secret_key:
-            auth_settings["jwt_secret_key"] = auth_config.jwt_secret_key
-        else:
-            # Will be resolved from Django settings at runtime
-            auth_settings["jwt_secret_key"] = None  # Signal to use Django SECRET_KEY
-
         return auth_settings
 
     def _build_grpc_proto_settings(self) -> Dict[str, Any]:
@@ -240,10 +232,13 @@ class GRPCSettingsGenerator:
         """
         Build list of server interceptors.
 
-        Interceptors are added in order:
-        1. Request logger interceptor (always enabled for monitoring)
-        2. Logging interceptor (if dev mode)
-        3. Auth interceptor (if auth enabled)
+        IMPORTANT: Interceptors are executed in reverse order for requests!
+        The first interceptor in the list wraps all others.
+
+        Correct order for our use case:
+        1. Auth interceptor (MUST be first to set context.api_key before logging)
+        2. Request logger interceptor (uses context.api_key from auth)
+        3. Logging interceptor (if dev mode)
         4. Metrics interceptor (if dev mode)
         5. Custom interceptors (from config)
 
@@ -255,30 +250,33 @@ class GRPCSettingsGenerator:
         # Check if we're in dev mode
         is_dev = self.config.env_mode in ("local", "development", "dev")
 
-        # Add request logger interceptor (always enabled for DB logging)
-        interceptors.append(
-            "django_cfg.apps.integrations.grpc.interceptors.RequestLoggerInterceptor"
-        )
+        # NOTE: Interceptors are applied in REVERSE order (last added = first executed)!
+        # So add them in reverse order of execution:
 
-        # Add logging interceptor in dev mode
+        # 4. Add metrics interceptor in dev mode (executed LAST)
         if is_dev:
             interceptors.append(
-                "django_cfg.apps.integrations.grpc.interceptors.LoggingInterceptor"
+                "django_cfg.apps.integrations.grpc.interceptors.MetricsInterceptor"
             )
 
-        # Add auth interceptor if enabled
-        if self.config.grpc.auth.enabled:
+        # 3. Add logging interceptor in dev mode (executed 3rd)
+        if is_dev:
             interceptors.append(
-                "django_cfg.apps.integrations.grpc.auth.JWTAuthInterceptor"
+                "django_cfg.apps.integrations.grpc.interceptors.LoggingInterceptor"
             )
 
-        # Add metrics interceptor in dev mode
-        if is_dev:
+        # 2. Add request logger interceptor (executed 2nd - needs context vars from auth)
+        interceptors.append(
+            "django_cfg.apps.integrations.grpc.interceptors.RequestLoggerInterceptor"
+        )
+
+        # 1. Add auth interceptor LAST in list (executed FIRST - sets contextvars!)
+        if self.config.grpc.auth.enabled:
             interceptors.append(
-                "django_cfg.apps.integrations.grpc.interceptors.MetricsInterceptor"
+                "django_cfg.apps.integrations.grpc.auth.ApiKeyAuthInterceptor"
             )
 
-        # Add custom interceptors from server config
+        # 5. Add custom interceptors from server config
         if self.config.grpc.server.interceptors:
             interceptors.extend(self.config.grpc.server.interceptors)
 

django_cfg/management/commands/check_endpoints.py

@@ -10,13 +10,13 @@ Usage:
 
 import json
 
-from django.core.management.base import BaseCommand
 from django.urls import reverse
 
 from django_cfg.apps.api.endpoints.endpoints_status.checker import check_all_endpoints
+from django_cfg.management.utils import SafeCommand
 
 
-class Command(BaseCommand):
+class Command(SafeCommand):
     help = 'Check status of all Django CFG API endpoints'
 
     def add_arguments(self, parser):

django_cfg/management/commands/check_settings.py

@@ -9,20 +9,13 @@ import os
 
 from django.conf import settings
 from django.core.mail import get_connection
-from django.core.management.base import BaseCommand
 
-from django_cfg.modules.django_logging import get_logger
+from django_cfg.management.utils import SafeCommand
 
-logger = get_logger('check_settings')
 
-class Command(BaseCommand):
+class Command(SafeCommand):
     """Command to check and debug django-cfg settings."""
 
-    # Web execution metadata
-    web_executable = True
-    requires_input = False
-    is_destructive = False
-
     help = "Check and debug django-cfg configuration settings"
 
     def add_arguments(self, parser):
@@ -39,7 +32,7 @@ class Command(BaseCommand):
 
     def handle(self, *args, **options):
         """Main command handler."""
-        logger.info("Starting check_settings command")
+        self.logger.info("Starting check_settings command")
         self.stdout.write(self.style.SUCCESS("\n🔍 Django CFG Settings Checker\n"))
 
         # Show basic info

django_cfg/management/commands/clear_constance.py

@@ -5,19 +5,12 @@ Clear Constance configuration cache and database records.
 
 from django.conf import settings
 from django.core.cache import cache
-from django.core.management.base import BaseCommand
 
-from django_cfg.modules.django_logging import get_logger
+from django_cfg.management.utils import DestructiveCommand
 
 
-class Command(BaseCommand):
-    logger = get_logger('clear_constance')
-
-    # Web execution metadata
-    web_executable = False
-    requires_input = True
-    is_destructive = True
-
+class Command(DestructiveCommand):
+    command_name = 'clear_constance'
     help = 'Clear Constance configuration cache and database records'
 
     def add_arguments(self, parser):

django_cfg/management/commands/create_token.py

@@ -10,21 +10,14 @@ from pathlib import Path
 
 import questionary
 from django.contrib.auth import get_user_model
-from django.core.management.base import BaseCommand
 
-from django_cfg.modules.django_logging import get_logger
+from django_cfg.management.utils import InteractiveCommand
 
 User = get_user_model()
 
 
-logger = get_logger('create_token')
-
-class Command(BaseCommand):
-    # Web execution metadata
-    web_executable = False
-    requires_input = True
-    is_destructive = False
-
+class Command(InteractiveCommand):
+    command_name = 'create_token'
     help = 'Create API tokens and authentication tokens'
 
     def add_arguments(self, parser):
@@ -52,7 +45,7 @@ class Command(BaseCommand):
         )
 
     def handle(self, *args, **options):
-        logger.info("Starting create_token command")
+        self.logger.info("Starting create_token command")
         if options['user'] and options['type']:
             self.create_token_for_user(
                 username=options['user'],

django_cfg/management/commands/list_urls.py

@@ -8,7 +8,6 @@ Useful for development and webhook configuration.
 import re
 
 from django.conf import settings
-from django.core.management.base import BaseCommand
 from django.urls import get_resolver
 from rich.align import Align
 
@@ -19,18 +18,13 @@ from rich.table import Table
 from rich.text import Text
 
 from django_cfg.core.state import get_current_config
-from django_cfg.modules.django_logging import get_logger
+from django_cfg.management.utils import SafeCommand
 
-logger = get_logger('list_urls')
 
-class Command(BaseCommand):
+class Command(SafeCommand):
     """Command to display all available URLs in the project."""
 
-    # Web execution metadata
-    web_executable = True
-    requires_input = False
-    is_destructive = False
-
+    command_name = 'list_urls'
     help = "Display all available URLs with Rich formatting"
 
     def __init__(self, *args, **kwargs):
@@ -62,7 +56,7 @@ class Command(BaseCommand):
         )
 
     def handle(self, *args, **options):
-        logger.info("Starting list_urls command")
+        self.logger.info("Starting list_urls command")
         filter_str = options["filter"]
         webhook_only = options["webhook"]
         api_only = options["api"]

django_cfg/management/commands/migrate_all.py

@@ -5,18 +5,24 @@ Migrate all databases based on django-cfg configuration.
 
 from django.apps import apps
 from django.core.management import call_command
-from django.core.management.base import BaseCommand
 
 from django_cfg.core.state import get_current_config
-from django_cfg.modules.django_logging import get_logger
+from django_cfg.management.utils import AdminCommand
 
-logger = get_logger('migrate_all')
 
-class Command(BaseCommand):
-    # Web execution metadata
-    web_executable = False
-    requires_input = False
-    is_destructive = True
+class Command(AdminCommand):
+    """
+    Migrate all databases - destructive but non-interactive admin command.
+
+    This command is marked as destructive because it modifies the database schema,
+    but it doesn't require user input during execution.
+    """
+
+    command_name = 'migrate_all'
+
+    # Override AdminCommand defaults
+    web_executable = False  # Too risky for web execution
+    is_destructive = True   # Modifies database schema
 
     help = "Migrate all databases based on django-cfg configuration"
 
@@ -34,7 +40,7 @@ class Command(BaseCommand):
 
     def handle(self, *args, **options):
         """Run migrations for all configured databases."""
-        logger.info("Starting migrate_all command")
+        self.logger.info("Starting migrate_all command")
         dry_run = options.get("dry_run", False)
         skip_makemigrations = options.get("skip_makemigrations", False)
 
@@ -76,7 +82,7 @@ class Command(BaseCommand):
                                 call_command("migrate", app_label, database=db_name, verbosity=1)
                             except Exception as e:
                                 self.stdout.write(self.style.ERROR(f"  ❌ Migration failed for {app_label} on {db_name}: {e}"))
-                                logger.error(f"Migration failed for {app_label} on {db_name}: {e}")
+                                self.logger.error(f"Migration failed for {app_label} on {db_name}: {e}")
                                 raise SystemExit(1)
                         else:
                             self.stdout.write(f"  Would run: migrate {app_label} --database={db_name}")
@@ -88,7 +94,7 @@ class Command(BaseCommand):
                         call_command("migrate", database=db_name, verbosity=1)
                     except Exception as e:
                         self.stdout.write(self.style.ERROR(f"  ❌ Migration failed for all apps on {db_name}: {e}"))
-                        logger.error(f"Migration failed for all apps on {db_name}: {e}")
+                        self.logger.error(f"Migration failed for all apps on {db_name}: {e}")
                         raise SystemExit(1)
                 else:
                     self.stdout.write(f"  Would run: migrate --database={db_name}")
@@ -100,7 +106,7 @@ class Command(BaseCommand):
                 call_command("migrate", "constance", database="default", verbosity=1)
             except Exception as e:
                 self.stdout.write(self.style.ERROR(f"❌ Constance migration failed: {e}"))
-                logger.error(f"Constance migration failed: {e}")
+                self.logger.error(f"Constance migration failed: {e}")
                 raise SystemExit(1)
         else:
             self.stdout.write("  Would run: migrate constance --database=default")

django_cfg/management/commands/migrator.py

@@ -9,22 +9,15 @@ import questionary
 from django.apps import apps
 from django.conf import settings
 from django.core.management import call_command
-from django.core.management.base import BaseCommand
 from django.db import connections
 from django.db.migrations.recorder import MigrationRecorder
 
 from django_cfg.core.config import DEFAULT_APPS
-from django_cfg.modules.django_logging import get_logger
+from django_cfg.management.utils import DestructiveCommand
 
-logger = get_logger('migrator')
-
-
-class Command(BaseCommand):
-    # Web execution metadata
-    web_executable = False
-    requires_input = True
-    is_destructive = True
 
+class Command(DestructiveCommand):
+    command_name = 'migrator'
     help = "Smart migration command with interactive menu for multiple databases"
 
     def add_arguments(self, parser):
@@ -132,7 +125,7 @@ class Command(BaseCommand):
 
     def _raise_system_exit(self, message):
         self.stdout.write(self.style.ERROR(f"❌ {message}"))
-        logger.error(message)
+        self.logger.error(message)
         # raise SystemExit(1)
 
     def migrate_database(self, db_name):

django_cfg/management/commands/script.py

@@ -10,18 +10,12 @@ from pathlib import Path
 import questionary
 from django.conf import settings
 from django.core.management import call_command
-from django.core.management.base import BaseCommand
-
-from django_cfg.modules.django_logging import get_logger
 
-logger = get_logger('script')
+from django_cfg.management.utils import InteractiveCommand
 
-class Command(BaseCommand):
-    # Web execution metadata
-    web_executable = False
-    requires_input = True
-    is_destructive = False
 
+class Command(InteractiveCommand):
+    command_name = 'script'
     help = 'Run custom scripts and manage Django applications'
 
     def add_arguments(self, parser):
@@ -52,7 +46,7 @@ class Command(BaseCommand):
         )
 
     def handle(self, *args, **options):
-        logger.info("Starting script command")
+        self.logger.info("Starting script command")
         if options['list']:
             self.list_scripts()
         elif options['create']:

django_cfg/management/commands/show_config.py

@@ -10,19 +10,11 @@ import json
 import os
 
 from django.conf import settings
-from django.core.management.base import BaseCommand
 
-from django_cfg.modules.django_logging import get_logger
+from django_cfg.management.utils import SafeCommand
 
-logger = get_logger('show_config')
-
-
-class Command(BaseCommand):
-    # Web execution metadata
-    web_executable = True
-    requires_input = False
-    is_destructive = False
 
+class Command(SafeCommand):
     help = 'Show Django Config configuration'
 
     def add_arguments(self, parser):
@@ -40,23 +32,23 @@ class Command(BaseCommand):
 
     def handle(self, *args, **options):
         """Show configuration in requested format."""
-        logger.info("Starting show_config command")
+        self.logger.info("Starting show_config command")
         try:
             # Get the config instance from Django settings
             config = self._get_config_instance()
-            logger.info("Successfully retrieved configuration instance")
+            self.logger.info("Successfully retrieved configuration instance")
 
             if options['format'] == 'json':
-                logger.info("Displaying configuration in JSON format")
+                self.logger.info("Displaying configuration in JSON format")
                 self._show_json_format(config, options['include_secrets'])
             else:
-                logger.info("Displaying configuration in table format")
+                self.logger.info("Displaying configuration in table format")
                 self._show_table_format(config, options['include_secrets'])
 
-            logger.info("show_config command completed successfully")
+            self.logger.info("show_config command completed successfully")
         except Exception as e:
             error_msg = f'Failed to show configuration: {e}'
-            logger.error(error_msg, exc_info=True)
+            self.logger.error(error_msg, exc_info=True)
             self.stdout.write(
                 self.style.ERROR(f'❌ {error_msg}')
             )

django_cfg/management/commands/show_urls.py

@@ -6,16 +6,14 @@ import re
 from typing import List, Optional, Tuple
 
 from django.conf import settings
-from django.core.management.base import BaseCommand, CommandParser
+from django.core.management.base import CommandParser
 from django.urls import get_resolver
 from django.utils.termcolors import make_style
 
-from django_cfg.modules.django_logging import get_logger
+from django_cfg.management.utils import SafeCommand
 
-logger = get_logger('show_urls')
 
-
-class Command(BaseCommand):
+class Command(SafeCommand):
     """
     Display all URL patterns in the Django project.
 
@@ -23,11 +21,7 @@ class Command(BaseCommand):
     in a hierarchical format with colors and filtering options.
     """
 
-    # Web execution metadata
-    web_executable = True
-    requires_input = False
-    is_destructive = False
-
+    command_name = 'show_urls'
     help = 'Display all URL patterns in the project'
 
     def __init__(self, *args, **kwargs):
@@ -88,7 +82,7 @@ class Command(BaseCommand):
 
     def handle(self, *args, **options) -> None:
         """Main command handler."""
-        logger.info("Starting show_urls command")
+        self.logger.info("Starting show_urls command")
         self.options = options
 
         # Disable colors if requested

django_cfg/management/commands/superuser.py

@@ -7,22 +7,15 @@ import questionary
 from django.contrib.auth import get_user_model
 from django.core.exceptions import ValidationError
 from django.core.management import call_command
-from django.core.management.base import BaseCommand
 from django.core.validators import validate_email
 
-from django_cfg.modules.django_logging import get_logger
+from django_cfg.management.utils import InteractiveCommand
 
 User = get_user_model()
 
 
-logger = get_logger('superuser')
-
-class Command(BaseCommand):
-    # Web execution metadata
-    web_executable = False
-    requires_input = True
-    is_destructive = False
-
+class Command(InteractiveCommand):
+    command_name = 'superuser'
     help = 'Create a superuser with enhanced validation and configuration'
 
     def add_arguments(self, parser):
@@ -58,7 +51,7 @@ class Command(BaseCommand):
         )
 
     def handle(self, *args, **options):
-        logger.info("Starting superuser command")
+        self.logger.info("Starting superuser command")
         if options['interactive'] or not any([options['username'], options['email'], options['password']]):
             self.create_superuser_interactive()
         else:

django_cfg/management/commands/tree.py

@@ -8,22 +8,17 @@ import subprocess
 from pathlib import Path
 
 from django.conf import settings
-from django.core.management.base import BaseCommand, CommandError
+from django.core.management.base import CommandError
 
 from django_cfg.core.state import get_current_config
-from django_cfg.modules.django_logging import get_logger
+from django_cfg.management.utils import SafeCommand
 from django_cfg.utils.path_resolution import PathResolver
 
-logger = get_logger('tree')
 
-class Command(BaseCommand):
+class Command(SafeCommand):
     """Display Django project structure in tree format."""
 
-    # Web execution metadata
-    web_executable = True
-    requires_input = False
-    is_destructive = False
-
+    command_name = 'tree'
     help = "Display Django project structure based on django-cfg configuration"
 
     def add_arguments(self, parser):
@@ -83,7 +78,7 @@ class Command(BaseCommand):
 
     def handle(self, *args, **options):
         """Execute the command."""
-        logger.info("Starting tree command")
+        self.logger.info("Starting tree command")
         try:
             # Get django-cfg configuration
             config = get_current_config()