django-cfg 1.4.46__py3-none-any.whl → 1.5.181__py3-none-any.whl

django_cfg/modules/django_logging/django_logger.py

@@ -2,9 +2,16 @@
 Simple auto-configuring Django Logger for django_cfg.
 
 KISS principle: simple, unified logging configuration.
+
+Features:
+- Modular logging with separate files per module
+- Automatic log rotation (daily, keeps 30 days)
+- INFO+ to files, WARNING+ to console
+- Auto-cleanup of old logs
 """
 
 import logging
+from logging.handlers import TimedRotatingFileHandler
 from pathlib import Path
 from typing import Any, Dict, Optional
 
@@ -58,6 +65,45 @@ class DjangoLogger(BaseCfgModule):
 
     _loggers: Dict[str, logging.Logger] = {}
     _configured = False
+    _debug_mode: Optional[bool] = None  # Cached debug mode to avoid repeated config loads
+
+    @classmethod
+    def _get_debug_mode(cls) -> bool:
+        """
+        Get debug mode from config dynamically (no caching).
+
+        Loads config each time to ensure we get the correct debug state.
+        This is necessary because config may not be ready when logger is first initialized.
+
+        Returns:
+            True if debug mode is enabled (config.debug or config.is_development), False otherwise
+        """
+        # Try Django settings first (most reliable)
+        try:
+            from django.conf import settings
+            if hasattr(settings, 'DEBUG'):
+                return settings.DEBUG
+        except Exception:
+            pass
+
+        # Try config second
+        try:
+            from django_cfg.core.state import get_current_config
+            config = get_current_config()
+
+            # Return debug if available, fallback to is_development
+            if config:
+                return config.debug if hasattr(config, 'debug') else config.is_development
+        except Exception:
+            pass
+
+        # Fallback to environment variables if nothing else works
+        import os
+        debug_env = os.getenv('DEBUG', 'false').lower() in ('true', '1', 'yes')
+        if debug_env:
+            return True
+        env_mode = os.getenv('ENV_MODE', '').lower()
+        return env_mode == 'development'
 
     @classmethod
     def get_logger(cls, name: str = "django_cfg") -> logging.Logger:
@@ -85,40 +131,64 @@ class DjangoLogger(BaseCfgModule):
         # print(f"  Django logs: {logs_dir / 'django.log'}")
         # print(f"  Django-CFG logs: {djangocfg_logs_dir}/")
 
-        # Get debug mode
-        try:
-            from django_cfg.core.state import get_current_config
-            config = get_current_config()
-            debug = config.debug if config else False
-        except Exception:
-            debug = os.getenv('DEBUG', 'false').lower() in ('true', '1', 'yes')
+        # Get debug mode (cached - loaded once)
+        debug = cls._get_debug_mode()
 
         # Create handlers
         try:
-            # Handler for general Django logs
+            # Handler for general Django logs with rotation
             django_log_path = logs_dir / 'django.log'
-            django_handler = logging.FileHandler(django_log_path, encoding='utf-8')
-            django_handler.setLevel(logging.DEBUG if debug else logging.WARNING)
+            django_handler = TimedRotatingFileHandler(
+                django_log_path,
+                when='midnight',  # Rotate at midnight
+                interval=1,  # Every 1 day
+                backupCount=30,  # Keep 30 days of logs
+                encoding='utf-8',
+            )
+            # File handlers ALWAYS capture DEBUG in dev mode (for complete debugging history)
+            # In production, still use INFO+ to save disk space
+            django_handler.setLevel(logging.DEBUG if debug else logging.INFO)
+
+            # /tmp handler - always enabled for easy `tail -f /tmp/djangocfg/debug.log`
+            # Set DJANGO_LOG_TO_TMP=false to disable
+            import os
+            tmp_handler = None
+            if os.getenv('DJANGO_LOG_TO_TMP', 'true').lower() not in ('false', '0', 'no'):
+                try:
+                    # Use /tmp/djangocfg/ directory
+                    tmp_log_dir = Path('/tmp') / 'djangocfg'
+                    tmp_log_dir.mkdir(parents=True, exist_ok=True)
+                    tmp_log_path = tmp_log_dir / 'debug.log'
+                    tmp_handler = logging.FileHandler(tmp_log_path, mode='a', encoding='utf-8')
+                    tmp_handler.setLevel(logging.DEBUG)  # Always capture everything
+                except Exception as e:
+                    print(f"[django-cfg] Failed to create /tmp/djangocfg/debug.log: {e}")
 
             # Console handler
             console_handler = logging.StreamHandler()
             console_handler.setLevel(logging.DEBUG if debug else logging.WARNING)
 
-            # Set format for handlers
+            # Set format for all handlers
             formatter = logging.Formatter('[%(asctime)s] %(levelname)s in %(name)s [%(filename)s:%(lineno)d]: %(message)s')
             django_handler.setFormatter(formatter)
             console_handler.setFormatter(formatter)
+            if tmp_handler:
+                tmp_handler.setFormatter(formatter)
 
-            # Configure root logger
+            # Configure root logger - ALWAYS DEBUG to let handlers filter
             root_logger = logging.getLogger()
-            root_logger.setLevel(logging.DEBUG if debug else logging.WARNING)
+            root_logger.setLevel(logging.DEBUG)  # CRITICAL: Always DEBUG, handlers filter
 
             # Clear existing handlers
             root_logger.handlers.clear()
 
             # Add handlers to root logger
             root_logger.addHandler(console_handler)
-            root_logger.addHandler(django_handler)  # All logs go to django.log
+            root_logger.addHandler(django_handler)
+            if tmp_handler:
+                root_logger.addHandler(tmp_handler)
+                # Test log to verify handler works
+                root_logger.info("[django-cfg] Logging initialized")
 
             # print(f"[django-cfg] Modular logging configured successfully! Debug: {debug}")
             cls._configured = True
@@ -136,9 +206,24 @@ class DjangoLogger(BaseCfgModule):
 
     @classmethod
     def _create_logger(cls, name: str) -> logging.Logger:
-        """Create logger with modular file handling for django-cfg loggers."""
+        """
+        Create logger with modular file handling for django-cfg loggers.
+
+        In dev/debug mode, loggers are set to DEBUG level to ensure all log messages
+        reach file handlers. Handlers still filter console output (WARNING+), but files
+        get everything (DEBUG+).
+        """
         logger = logging.getLogger(name)
 
+        # Get debug mode (cached - loaded once)
+        debug = cls._get_debug_mode()
+
+        # CRITICAL: ALWAYS set DEBUG level on django_cfg loggers
+        # This ensures all messages (DEBUG/INFO/WARNING/ERROR) can reach handlers
+        # Handlers will do the filtering, not the logger itself
+        if name.startswith('django_cfg'):
+            logger.setLevel(logging.DEBUG)
+
         # If this is a django-cfg logger, add a specific file handler
         if name.startswith('django_cfg'):
             try:
@@ -159,18 +244,21 @@ class DjangoLogger(BaseCfgModule):
 
                 log_file_path = djangocfg_logs_dir / f'{module_name}.log'
 
-                # Create file handler for this specific module
-                file_handler = logging.FileHandler(log_file_path, encoding='utf-8')
+                # Create rotating file handler for this specific module
+                file_handler = TimedRotatingFileHandler(
+                    log_file_path,
+                    when='midnight',  # Rotate at midnight
+                    interval=1,  # Every 1 day
+                    backupCount=30,  # Keep 30 days of logs
+                    encoding='utf-8',
+                )
 
-                # Get debug mode
-                try:
-                    from django_cfg.core.state import get_current_config
-                    config = get_current_config()
-                    debug = config.debug if config else False
-                except Exception:
-                    debug = os.getenv('DEBUG', 'false').lower() in ('true', '1', 'yes')
+                # Get debug mode (cached - loaded once)
+                debug = cls._get_debug_mode()
 
-                file_handler.setLevel(logging.DEBUG if debug else logging.WARNING)
+                # Module file handlers ALWAYS capture DEBUG in dev mode
+                # This ensures complete log history for debugging, independent of logger level
+                file_handler.setLevel(logging.DEBUG if debug else logging.INFO)
 
                 # Set format
                 formatter = logging.Formatter('[%(asctime)s] %(levelname)s in %(name)s [%(filename)s:%(lineno)d]: %(message)s')
@@ -188,18 +276,85 @@ class DjangoLogger(BaseCfgModule):
         return logger
 
 
+def clean_old_logs(days: int = 30, logs_dir: Optional[Path] = None) -> Dict[str, int]:
+    """
+    Clean up log files older than specified days.
+
+    Args:
+        days: Number of days to keep (default: 30)
+        logs_dir: Optional custom logs directory (default: ./logs)
+
+    Returns:
+        Dictionary with cleanup statistics
+
+    Example:
+        >>> from django_cfg.modules.django_logging import clean_old_logs
+        >>> stats = clean_old_logs(days=7)  # Keep only last 7 days
+        >>> print(f"Deleted {stats['deleted']} files, freed {stats['bytes']} bytes")
+    """
+    import os
+    from datetime import datetime, timedelta
+
+    if logs_dir is None:
+        current_dir = Path(os.getcwd())
+        logs_dir = current_dir / 'logs'
+
+    if not logs_dir.exists():
+        return {'deleted': 0, 'bytes': 0, 'error': 'Logs directory not found'}
+
+    cutoff_date = datetime.now() - timedelta(days=days)
+    deleted_count = 0
+    deleted_bytes = 0
+
+    # Recursively find all .log files (including rotated ones like .log.2024-11-01)
+    for log_file in logs_dir.rglob('*.log*'):
+        if log_file.is_file():
+            try:
+                # Check file modification time
+                mtime = datetime.fromtimestamp(log_file.stat().st_mtime)
+                if mtime < cutoff_date:
+                    file_size = log_file.stat().st_size
+                    log_file.unlink()
+                    deleted_count += 1
+                    deleted_bytes += file_size
+            except Exception as e:
+                print(f"[django-cfg] Error deleting {log_file}: {e}")
+
+    return {
+        'deleted': deleted_count,
+        'bytes': deleted_bytes,
+        'human_readable': f"{deleted_bytes / 1024 / 1024:.2f} MB" if deleted_bytes > 0 else "0 MB",
+    }
+
+
 # Convenience function for quick access
-def get_logger(name: str = "django_cfg") -> logging.Logger:
+def get_logger(name: str = "") -> logging.Logger:
     """
     Get a configured logger instance with automatic django-cfg prefix detection.
-    
-    If called from django-cfg modules, automatically prefixes with 'django_cfg.'
+
+    Automatically detects module path from caller's filename and creates proper logger name.
+    If name doesn't start with 'django_cfg', it will be auto-prefixed.
+
+    Examples:
+        # Auto-detect from file path
+        logger = get_logger()  # -> django_cfg.integrations.rq (from file path)
+
+        # Explicit module name (auto-prefixed)
+        logger = get_logger("integrations")  # -> django_cfg.integrations
+        logger = get_logger("payments.stripe")  # -> django_cfg.payments.stripe
+
+        # Already prefixed (used as-is)
+        logger = get_logger("django_cfg.custom.name")  # -> django_cfg.custom.name
     """
     import inspect
+    import os
+
+    # If name is already prefixed with django_cfg, use as-is
+    if name and name.startswith('django_cfg'):
+        return DjangoLogger.get_logger(name)
 
     # Auto-detect if we're being called from django-cfg code
-    if not name.startswith('django_cfg'):
-        # Get the calling frame to determine if we're in django-cfg code
+    if not name or not name.startswith('django_cfg'):
         frame = inspect.currentframe()
         try:
             # Go up the call stack to find the actual caller
@@ -210,39 +365,64 @@ def get_logger(name: str = "django_cfg") -> logging.Logger:
                 # Check if caller is from django-cfg modules
                 if '/django_cfg/' in caller_filename:
                     # Extract module path from filename
-                    # e.g., /path/to/django_cfg/apps/payments/services/providers/registry.py
-                    # -> django_cfg.payments.providers
-
                     parts = caller_filename.split('/django_cfg/')
                     if len(parts) > 1:
-                        module_path = parts[1]  # apps/payments/services/providers/registry.py
-
-                        # Convert path to module name
-                        if module_path.startswith('apps/'):
-                            # apps/payments/services/providers/registry.py -> payments.providers
-                            path_parts = module_path.split('/')[1:]  # Remove 'apps'
-                            if path_parts:
-                                # Remove file extension and 'services' if present
-                                clean_parts = []
-                                for part in path_parts[:-1]:  # Exclude filename
-                                    if part not in ['services', 'management', 'commands']:
-                                        clean_parts.append(part)
-
-                                if clean_parts:
-                                    auto_name = f"django_cfg.{'.'.join(clean_parts)}"
-                                    # print(f"[django-cfg] Auto-detected logger name: {name} -> {auto_name}")
-                                    name = auto_name
-
-                        elif module_path.startswith('modules/'):
-                            # modules/django_logger.py -> django_cfg.core
-                            name = "django_cfg.core"
-
-                        elif module_path.startswith('core/'):
-                            # core/config.py -> django_cfg.core
-                            name = "django_cfg.core"
+                        module_path = parts[1]  # e.g., apps/integrations/rq/tasks/demo_tasks.py
+
+                        # Remove file extension
+                        module_path = os.path.splitext(module_path)[0]  # apps/integrations/rq/tasks/demo_tasks
+
+                        # Convert path separators to dots
+                        path_parts = module_path.split('/')
+
+                        # Build clean module name based on location
+                        clean_parts = []
+
+                        if path_parts[0] == 'apps':
+                            # apps/integrations/rq/tasks/demo_tasks -> integrations.rq.tasks
+                            # Skip 'apps' and filename, keep directories
+                            for part in path_parts[1:-1]:  # Skip 'apps' and filename
+                                if part not in ['services', 'management', 'commands', 'views', 'models']:
+                                    clean_parts.append(part)
+
+                            # If user provided a name, append it; otherwise use default hierarchy
+                            # If user provided a name, append it; otherwise use default hierarchy
+                            if name:
+                                clean_parts.append(name)
+
+                        elif path_parts[0] == 'modules':
+                            # modules/django_logging/logger.py -> core
+                            clean_parts = ['core']
+                            if name:
+                                clean_parts.append(name)
+
+                        elif path_parts[0] == 'core':
+                            # core/config.py -> core
+                            clean_parts = ['core']
+                            if name:
+                                clean_parts.append(name)
+
+                        else:
+                            # Fallback: use all parts except filename
+                            clean_parts = path_parts[:-1]
+                            if name:
+                                clean_parts.append(name)
+
+                        if clean_parts:
+                            auto_name = f"django_cfg.{'.'.join(clean_parts)}"
+                            name = auto_name
+
         finally:
             del frame
 
+    # If we still have a name without django_cfg prefix, add it
+    if name and not name.startswith('django_cfg'):
+        name = f"django_cfg.{name}"
+
+    # Fallback to default if still no name
+    if not name:
+        name = "django_cfg"
+
     return DjangoLogger.get_logger(name)
 
 

django_cfg/modules/django_ngrok/management/commands/runserver_ngrok.py

@@ -9,11 +9,9 @@ import time
 
 from django.core.management.commands.runserver import Command as RunServerCommand
 
-from django_cfg.modules.django_logging import get_logger
+from django_cfg.utils import get_logger
 from django_cfg.modules.django_ngrok import get_ngrok_service
 
-logger = get_logger('runserver_ngrok')
-
 
 class Command(RunServerCommand):
     """Enhanced runserver command with ngrok tunnel support."""
@@ -25,6 +23,11 @@ class Command(RunServerCommand):
 
     help = f'{RunServerCommand.help.rstrip(".")} with ngrok tunnel.'
 
+    def __init__(self, *args, **kwargs):
+        """Initialize with logger."""
+        super().__init__(*args, **kwargs)
+        self.logger = get_logger('runserver_ngrok')
+
     def add_arguments(self, parser):
         super().add_arguments(parser)
         parser.add_argument(
@@ -76,14 +79,14 @@ class Command(RunServerCommand):
         ngrok_service = get_ngrok_service()
 
         self.stdout.write("🚇 Starting ngrok tunnel...")
-        logger.info(f"Starting ngrok tunnel for port {server_port}")
+        self.logger.info(f"Starting ngrok tunnel for port {server_port}")
 
         tunnel_url = ngrok_service.start_tunnel(server_port)
 
         if tunnel_url:
             # Wait for tunnel to be fully established
             self.stdout.write("⏳ Waiting for tunnel to be established...")
-            logger.info("Waiting for ngrok tunnel to be fully established")
+            self.logger.info("Waiting for ngrok tunnel to be fully established")
 
             max_retries = 10
             retry_count = 0
@@ -98,10 +101,10 @@ class Command(RunServerCommand):
                     current_url = ngrok_service.get_tunnel_url()
                     if current_url and current_url == tunnel_url:
                         tunnel_ready = True
-                        logger.info(f"Ngrok tunnel established successfully: {tunnel_url}")
+                        self.logger.info(f"Ngrok tunnel established successfully: {tunnel_url}")
                         break
                 except Exception as e:
-                    logger.warning(f"Tunnel check attempt {retry_count} failed: {e}")
+                    self.logger.warning(f"Tunnel check attempt {retry_count} failed: {e}")
 
                 self.stdout.write(f"⏳ Tunnel check {retry_count}/{max_retries}...")
 
@@ -116,16 +119,16 @@ class Command(RunServerCommand):
                 self.stdout.write(
                     self.style.SUCCESS(f"✅ Ngrok tunnel ready: {tunnel_url}")
                 )
-                logger.info(f"Ngrok tunnel fully ready: {tunnel_url}")
+                self.logger.info(f"Ngrok tunnel fully ready: {tunnel_url}")
             else:
                 self.stdout.write(
                     self.style.WARNING("⚠️ Ngrok tunnel started but may not be fully ready")
                 )
-                logger.warning("Ngrok tunnel started but readiness check failed")
+                self.logger.warning("Ngrok tunnel started but readiness check failed")
         else:
             error_msg = "Failed to start ngrok tunnel"
             self.stdout.write(self.style.ERROR(f"❌ {error_msg}"))
-            logger.error(error_msg)
+            self.logger.error(error_msg)
 
     def _set_ngrok_env_vars(self, tunnel_url: str):
         """Set environment variables with ngrok URL for easy access."""
@@ -145,10 +148,10 @@ class Command(RunServerCommand):
             os.environ['NGROK_API_URL'] = tunnel_url
 
             # Environment variables set - no need for verbose output
-            logger.info(f"Set ngrok environment variables: {tunnel_url}")
+            self.logger.info(f"Set ngrok environment variables: {tunnel_url}")
 
         except Exception as e:
-            logger.warning(f"Could not set ngrok environment variables: {e}")
+            self.logger.warning(f"Could not set ngrok environment variables: {e}")
 
     def _update_allowed_hosts(self, tunnel_url: str):
         """Update ALLOWED_HOSTS with ngrok domain."""
@@ -164,7 +167,7 @@ class Command(RunServerCommand):
             if hasattr(settings, 'ALLOWED_HOSTS'):
                 if ngrok_host not in settings.ALLOWED_HOSTS:
                     settings.ALLOWED_HOSTS.append(ngrok_host)
-                    logger.info(f"Added {ngrok_host} to ALLOWED_HOSTS")
+                    self.logger.info(f"Added {ngrok_host} to ALLOWED_HOSTS")
 
         except Exception as e:
-            logger.warning(f"Could not update ALLOWED_HOSTS: {e}")
+            self.logger.warning(f"Could not update ALLOWED_HOSTS: {e}")

django_cfg/modules/django_tailwind/templates/django_tailwind/base.html

@@ -9,10 +9,17 @@
     <!-- Tailwind CSS (compiled via django-tailwind) -->
     {% tailwind_css %}
 
+    <!-- Alpine.js will be loaded by pages that need it AFTER their modules load -->
+
+    <!-- JWT Token for API authentication -->
+    <script>
+        {% load django_cfg %}
+        window.USER_JWT_TOKEN = '{% user_jwt_token %}';
+    </script>
+
     {% block extra_head %}{% endblock %}
 
-    <!-- Alpine.js for interactivity -->
-    <script defer src="https://unpkg.com/alpinejs@3.x.x/dist/cdn.min.js"></script>
+    <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
 
     <style>
         /* Prevent flash of unstyled content */
@@ -26,19 +33,27 @@
     </style>
 
     <!-- Dark mode initialization (prevents flash) -->
+    <!-- Supports both django-tailwind darkMode and Unfold theme keys -->
     <script>
         (function() {
-            const isDark = localStorage.getItem('darkMode') === 'true' ||
-                          (!localStorage.getItem('darkMode') && window.matchMedia('(prefers-color-scheme: dark)').matches);
+            // Check multiple sources for dark mode preference
+            const unfoldTheme = localStorage.getItem('theme'); // Unfold uses 'theme' key with 'dark'/'light' values
+            const legacyDarkMode = localStorage.getItem('darkMode'); // Legacy django-tailwind key
+            const systemPrefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+
+            const isDark = unfoldTheme === 'dark' ||
+                          legacyDarkMode === 'true' ||
+                          (!unfoldTheme && !legacyDarkMode && systemPrefersDark);
+
             if (isDark) {
                 document.documentElement.classList.add('dark');
             }
         })();
     </script>
 </head>
-<body class="h-full bg-gray-50 dark:bg-gray-900"
-      x-data="{ darkMode: localStorage.getItem('darkMode') === 'true' || (!localStorage.getItem('darkMode') && window.matchMedia('(prefers-color-scheme: dark)').matches){% block alpine_data_extra %}{% endblock %} }"
-      x-init="$watch('darkMode', val => { localStorage.setItem('darkMode', val); document.documentElement.classList.toggle('dark', val); }){% block alpine_init_extra %}{% endblock %}">
+<body class="h-full bg-gray-50 dark:bg-gray-950"
+      x-data="{ darkMode: localStorage.getItem('theme') === 'dark' || localStorage.getItem('darkMode') === 'true' || (!localStorage.getItem('theme') && !localStorage.getItem('darkMode') && window.matchMedia('(prefers-color-scheme: dark)').matches){% block alpine_data_extra %}{% endblock %} }"
+      x-init="$watch('darkMode', val => { localStorage.setItem('darkMode', val); localStorage.setItem('theme', val ? 'dark' : 'light'); document.documentElement.classList.toggle('dark', val); }){% block alpine_init_extra %}{% endblock %}">
 
     {% block body %}
     <div class="min-h-full flex flex-col">
@@ -55,20 +70,20 @@
 
         {% block footer %}
         {% load django_cfg %}
-        <footer class="bg-white dark:bg-gray-800 border-t border-gray-200 dark:border-gray-700 mt-auto">
+        <footer class="bg-white dark:bg-gray-900 border-t border-gray-200 dark:border-gray-700 mt-auto">
             <div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-6">
                 {% block footer_content %}
                 <div class="text-center">
                     {% block footer_text %}
-                    <p class="text-sm text-gray-600 dark:text-gray-400">
+                    <p class="text-sm text-gray-700 dark:text-gray-300">
                         Powered by
                         <a href="{% lib_site_url %}"
-                           class="text-blue-600 dark:text-blue-400 hover:text-blue-700 dark:hover:text-blue-300 font-medium transition-colors"
+                           class="text-indigo-600 dark:text-indigo-400 hover:text-indigo-700 dark:hover:text-indigo-300 font-medium transition-colors"
                            target="_blank" rel="noopener noreferrer">
                             {% lib_name %}
                         </a>
                     </p>
-                    <p class="mt-2 text-xs text-gray-500 dark:text-gray-500">
+                    <p class="mt-2 text-xs text-gray-500 dark:text-gray-400">
                         {% lib_subtitle %}
                     </p>
                     {% endblock %}

django_cfg/modules/django_tailwind/templates/django_tailwind/components/navbar.html

@@ -67,13 +67,13 @@ Custom navbar (extending):
                 <nav class="hidden md:flex items-center space-x-1">
                     {% for item in nav_items %}
                     <a href="{{ item.url }}"
-                       class="px-3 py-2 rounded-md text-sm font-medium transition-colors
+                       class="px-3 py-2 rounded-md text-sm font-medium transition-colors flex items-center gap-1.5
                               {% if item.active %}
                                   bg-gray-100 dark:bg-gray-700 text-gray-900 dark:text-white
                               {% else %}
                                   text-gray-600 dark:text-gray-300 hover:bg-gray-50 dark:hover:bg-gray-700 hover:text-gray-900 dark:hover:text-white
                               {% endif %}">
-                        {% if item.icon %}<span class="mr-1">{{ item.icon }}</span>{% endif %}
+                        {% if item.icon %}<span class="material-icons text-sm">{{ item.icon }}</span>{% endif %}
                         {{ item.label }}
                     </a>
                     {% endfor %}

django_cfg/modules/django_tailwind/templates/django_tailwind/simple.html

@@ -2,16 +2,21 @@
 
 {% block container_class %}{% endblock %}
 
+{% block header %}{% endblock %}
+{% block footer %}{% endblock %}
+
 {% block main %}
+{% block theme_toggle %}
 <!-- Floating Dark Mode Toggle -->
 <div class="fixed top-4 right-4 z-50">
     {% include 'django_tailwind/components/theme_toggle.html' %}
 </div>
+{% endblock %}
 
 <div class="min-h-screen flex items-center justify-center px-4 py-12">
     <div class="w-full max-w-md">
         {% block content %}
-        <div class="bg-white dark:bg-gray-800 rounded-lg shadow-lg p-8 text-center">
+        <div class="bg-white dark:bg-gray-900 border border-gray-200 dark:border-gray-700 rounded-lg shadow-lg p-8 text-center">
             {% block simple_icon %}
             <div class="text-6xl mb-4">
                 {% block icon %}ℹ️{% endblock %}
@@ -19,13 +24,13 @@
             {% endblock %}
 
             {% block simple_title %}
-            <h1 class="text-2xl font-bold text-gray-900 dark:text-white mb-4">
+            <h1 class="text-2xl font-bold text-gray-900 dark:text-gray-100 mb-4">
                 {% block heading %}Title{% endblock %}
             </h1>
             {% endblock %}
 
             {% block simple_message %}
-            <p class="text-gray-600 dark:text-gray-400 mb-6">
+            <p class="text-gray-700 dark:text-gray-300 mb-6">
                 {% block message %}Message goes here{% endblock %}
             </p>
             {% endblock %}
@@ -34,13 +39,14 @@
             <div class="flex flex-col sm:flex-row gap-3 justify-center">
                 {% block actions %}
                 <a href="/"
-                   class="inline-flex items-center justify-center px-6 py-3 border border-transparent rounded-lg shadow-sm text-base font-medium text-white bg-blue-600 hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-blue-500 transition-colors">
+                   class="inline-flex items-center justify-center px-6 py-3 border border-transparent rounded-lg shadow-sm text-base font-medium text-white bg-indigo-600 hover:bg-indigo-700 dark:bg-indigo-500 dark:hover:bg-indigo-600 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500 transition-colors">
                     Go Home
                 </a>
                 {% endblock %}
             </div>
             {% endblock %}
         </div>
+        {% endblock %}
     </div>
 </div>
 {% endblock %}

django_cfg/modules/django_telegram/__init__.py

@@ -6,6 +6,7 @@ Auto-configuring Telegram notification service that integrates with DjangoConfig
 
 from .service import (
     DjangoTelegram,
+    MessagePriority,
     TelegramConfigError,
     TelegramError,
     TelegramParseMode,
@@ -23,6 +24,7 @@ __all__ = [
     "TelegramConfigError",
     "TelegramSendError",
     "DjangoTelegram",
+    "MessagePriority",
     "send_telegram_message",
     "send_telegram_photo",
     "send_telegram_document",