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

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

@@ -6,9 +6,11 @@ Simple implementation following KISS principle.
 
 import os
 import time
+
 from django.core.management.commands.runserver import Command as RunServerCommand
-from django_cfg.modules.django_ngrok import get_ngrok_service
+
 from django_cfg.modules.django_logging import get_logger
+from django_cfg.modules.django_ngrok import get_ngrok_service
 
 logger = get_logger('runserver_ngrok')
 
@@ -22,7 +24,7 @@ class Command(RunServerCommand):
     is_destructive = False
 
     help = f'{RunServerCommand.help.rstrip(".")} with ngrok tunnel.'
-    
+
     def add_arguments(self, parser):
         super().add_arguments(parser)
         parser.add_argument(
@@ -34,19 +36,19 @@ class Command(RunServerCommand):
             action='store_true',
             help='Disable ngrok tunnel even if configured'
         )
-    
+
     def handle(self, *args, **options):
         """Handle the command with ngrok integration."""
-        
+
         # Check if ngrok should be disabled
         if options.get('no_ngrok'):
             self.stdout.write("Ngrok disabled by --no-ngrok flag")
             return super().handle(*args, **options)
-        
+
         # Get ngrok service
         try:
             ngrok_service = get_ngrok_service()
-            
+
             # Check if ngrok is configured and enabled
             config = ngrok_service.get_config()
             if not config or not hasattr(config, 'ngrok') or not config.ngrok or not config.ngrok.enabled:
@@ -55,42 +57,42 @@ class Command(RunServerCommand):
         except Exception as e:
             self.stdout.write(f"Error accessing ngrok configuration: {e}")
             return super().handle(*args, **options)
-        
+
         # Override domain if provided
         if options.get('domain'):
             config.ngrok.tunnel.domain = options['domain']
-        
+
         # Start the server normally first
         self.stdout.write("Starting Django development server...")
-        
+
         # Call parent handle but intercept the server start
         return super().handle(*args, **options)
-    
+
     def on_bind(self, server_port):
         """Called when server binds to port - start ngrok tunnel here."""
         super().on_bind(server_port)
-        
+
         # Start ngrok tunnel
         ngrok_service = get_ngrok_service()
-        
+
         self.stdout.write("🚇 Starting ngrok tunnel...")
         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")
-            
+
             max_retries = 10
             retry_count = 0
             tunnel_ready = False
-            
+
             while retry_count < max_retries and not tunnel_ready:
                 time.sleep(1)
                 retry_count += 1
-                
+
                 # Check if tunnel is actually accessible
                 try:
                     current_url = ngrok_service.get_tunnel_url()
@@ -100,9 +102,9 @@ class Command(RunServerCommand):
                         break
                 except Exception as e:
                     logger.warning(f"Tunnel check attempt {retry_count} failed: {e}")
-                
+
                 self.stdout.write(f"⏳ Tunnel check {retry_count}/{max_retries}...")
-            
+
             if tunnel_ready:
                 # Set environment variables for ngrok URL
                 self._set_ngrok_env_vars(tunnel_url)
@@ -124,44 +126,45 @@ class Command(RunServerCommand):
             error_msg = "Failed to start ngrok tunnel"
             self.stdout.write(self.style.ERROR(f"❌ {error_msg}"))
             logger.error(error_msg)
-    
+
     def _set_ngrok_env_vars(self, tunnel_url: str):
         """Set environment variables with ngrok URL for easy access."""
         try:
             from urllib.parse import urlparse
-            
+
             # Set main ngrok URL
             os.environ['NGROK_URL'] = tunnel_url
             os.environ['DJANGO_NGROK_URL'] = tunnel_url
-            
+
             # Parse URL components
             parsed = urlparse(tunnel_url)
             os.environ['NGROK_HOST'] = parsed.netloc
             os.environ['NGROK_SCHEME'] = parsed.scheme
-            
+
             # Set API URL (same as tunnel URL for most cases)
             os.environ['NGROK_API_URL'] = tunnel_url
-            
+
             # Environment variables set - no need for verbose output
             logger.info(f"Set ngrok environment variables: {tunnel_url}")
-            
+
         except Exception as e:
             logger.warning(f"Could not set ngrok environment variables: {e}")
-    
+
     def _update_allowed_hosts(self, tunnel_url: str):
         """Update ALLOWED_HOSTS with ngrok domain."""
         try:
-            from django.conf import settings
             from urllib.parse import urlparse
-            
+
+            from django.conf import settings
+
             parsed = urlparse(tunnel_url)
             ngrok_host = parsed.netloc
-            
+
             # Add to ALLOWED_HOSTS if not already present
             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")
-        
+
         except Exception as e:
             logger.warning(f"Could not update ALLOWED_HOSTS: {e}")

django_cfg/modules/django_ngrok/service.py

@@ -4,12 +4,13 @@ Django Ngrok Service for django_cfg.
 Simple ngrok integration following KISS principle.
 """
 
-import os
-import logging
 import atexit
+import logging
+import os
 from typing import Optional
-from django_cfg.modules.base import BaseCfgModule
+
 from django_cfg.models.ngrok import NgrokConfig
+from django_cfg.modules.base import BaseCfgModule
 
 logger = logging.getLogger(__name__)
 
@@ -21,15 +22,15 @@ class NgrokError(Exception):
 
 class NgrokManager:
     """Simple ngrok tunnel manager."""
-    
+
     def __init__(self, config: NgrokConfig):
         self.config = config
         self.tunnel_url: Optional[str] = None
         self.listener = None
-        
+
         # Register cleanup on exit
         atexit.register(self.cleanup)
-    
+
     def start_tunnel(self, port: int = 8000) -> Optional[str]:
         """Start ngrok tunnel for given port."""
         if not self.config.enabled:
@@ -68,7 +69,7 @@ class NgrokManager:
         except Exception as e:
             logger.error(f"Failed to start ngrok tunnel: {e}")
             return None
-    
+
     def stop_tunnel(self) -> None:
         """Stop ngrok tunnel."""
         if self.listener:
@@ -80,15 +81,15 @@ class NgrokManager:
             finally:
                 self.listener = None
                 self.tunnel_url = None
-    
+
     def get_tunnel_url(self) -> Optional[str]:
         """Get current tunnel URL."""
         return self.tunnel_url
-    
+
     def is_active(self) -> bool:
         """Check if tunnel is active."""
         return self.tunnel_url is not None
-    
+
     def cleanup(self) -> None:
         """Cleanup on exit."""
         if self.is_active():
@@ -98,11 +99,11 @@ class NgrokManager:
 
 class DjangoNgrok(BaseCfgModule):
     """Main ngrok service for django-cfg."""
-    
+
     def __init__(self):
         super().__init__()
         self._manager: Optional[NgrokManager] = None
-    
+
     @property
     def manager(self) -> Optional[NgrokManager]:
         """Get ngrok manager (lazy-loaded)."""
@@ -115,28 +116,28 @@ class DjangoNgrok(BaseCfgModule):
                 logger.warning(f"Failed to get ngrok config: {e}")
                 return None
         return self._manager
-    
+
     @manager.setter
     def manager(self, value: Optional[NgrokManager]) -> None:
         """Set NgrokManager instance (for testing)."""
         self._manager = value
-    
+
     @manager.deleter
     def manager(self) -> None:
         """Delete NgrokManager instance (for testing)."""
         self._manager = None
-    
+
     def start_tunnel(self, port: int = 8000) -> Optional[str]:
         """Start ngrok tunnel."""
         if not self.manager:
             return None
         return self.manager.start_tunnel(port)
-    
+
     def stop_tunnel(self) -> None:
         """Stop ngrok tunnel."""
         if self.manager:
             self.manager.stop_tunnel()
-    
+
     def get_tunnel_url(self) -> Optional[str]:
         """Get current tunnel URL from manager or environment variables."""
         # First try to get from manager (active tunnel)
@@ -144,16 +145,16 @@ class DjangoNgrok(BaseCfgModule):
             tunnel_url = self.manager.get_tunnel_url()
             if tunnel_url:
                 return tunnel_url
-        
+
         # Fallback to environment variables (set by runserver_ngrok)
         return self.get_tunnel_url_from_env()
-    
+
     def is_tunnel_active(self) -> bool:
         """Check if tunnel is active."""
         if not self.manager:
             return False
         return self.manager.is_active()
-    
+
     def get_webhook_url(self, path: str = "/webhooks/") -> str:
         """Get webhook URL with ngrok tunnel or fallback to api_url."""
         # Try to get tunnel URL first
@@ -174,46 +175,46 @@ class DjangoNgrok(BaseCfgModule):
 
         # Ultimate fallback
         return f"http://localhost:8000/{path.lstrip('/')}"
-    
+
     def get_api_url(self) -> str:
         """Get API URL - tunnel URL if active, otherwise config api_url."""
         # Try tunnel URL first
         tunnel_url = self.get_tunnel_url()
         if tunnel_url:
             return tunnel_url
-        
+
         # Fallback to config api_url
         config = self.get_config()
         if config and hasattr(config, 'api_url'):
             return config.api_url
-        
+
         # Ultimate fallback
         return "http://localhost:8000"
-    
+
     def get_tunnel_url_from_env(self) -> Optional[str]:
         """Get ngrok tunnel URL from environment variables."""
         # Try different environment variable names
         env_vars = ['NGROK_URL', 'DJANGO_NGROK_URL', 'NGROK_API_URL']
-        
+
         for env_var in env_vars:
             url = os.environ.get(env_var)
             if url and url.startswith(('http://', 'https://')):
                 return url
-        
+
         return None
-    
+
     def get_ngrok_host_from_env(self) -> Optional[str]:
         """Get ngrok host from environment variables."""
         return os.environ.get('NGROK_HOST')
-    
+
     def get_ngrok_scheme_from_env(self) -> Optional[str]:
         """Get ngrok scheme from environment variables."""
         return os.environ.get('NGROK_SCHEME', 'https')
-    
+
     def is_ngrok_available_from_env(self) -> bool:
         """Check if ngrok URL is available from environment variables."""
         return self.get_tunnel_url_from_env() is not None
-    
+
     def get_effective_tunnel_url(self) -> Optional[str]:
         """Get effective tunnel URL (alias for get_tunnel_url for clarity)."""
         return self.get_tunnel_url()
@@ -284,11 +285,11 @@ def get_effective_tunnel_url() -> Optional[str]:
 # Export public API
 __all__ = [
     "DjangoNgrok",
-    "NgrokManager", 
+    "NgrokManager",
     "NgrokError",
     "get_ngrok_service",
     "start_tunnel",
-    "stop_tunnel", 
+    "stop_tunnel",
     "get_tunnel_url",
     "get_webhook_url",
     "get_api_url",

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

@@ -9,11 +9,11 @@
     <!-- Tailwind CSS (compiled via django-tailwind) -->
     {% tailwind_css %}
 
+    {% block extra_head %}{% endblock %}
+
     <!-- Alpine.js for interactivity -->
     <script defer src="https://unpkg.com/alpinejs@3.x.x/dist/cdn.min.js"></script>
 
-    {% block extra_head %}{% endblock %}
-
     <style>
         /* Prevent flash of unstyled content */
         [x-cloak] { display: none !important; }
@@ -21,40 +21,8 @@
         /* Override Tailwind's media-query dark mode with class-based dark mode */
         /* This ensures dark: classes work when .dark is on <html>, not just media queries */
 
-        /* Force light mode when NOT in dark mode - override media queries */
-        @media (prefers-color-scheme: dark) {
-            html:not(.dark) body,
-            html:not(.dark) .dark\:bg-gray-900,
-            html:not(.dark) .dark\:bg-gray-800,
-            html:not(.dark) .dark\:bg-gray-700,
-            html:not(.dark) .dark\:bg-gray-600 {
-                background-color: inherit !important;
-            }
-
-            html:not(.dark) .dark\:text-gray-100,
-            html:not(.dark) .dark\:text-white,
-            html:not(.dark) .dark\:text-gray-300,
-            html:not(.dark) .dark\:text-gray-400,
-            html:not(.dark) .dark\:text-gray-500 {
-                color: inherit !important;
-            }
-
-            html:not(.dark) .dark\:border-gray-700,
-            html:not(.dark) .dark\:border-gray-600,
-            html:not(.dark) .dark\:border-gray-800 {
-                border-color: inherit !important;
-            }
-
-            html:not(.dark) .dark\:hover\:bg-gray-700:hover,
-            html:not(.dark) .dark\:hover\:bg-gray-800:hover {
-                background-color: inherit !important;
-            }
-
-            html:not(.dark) .dark\:hover\:text-white:hover,
-            html:not(.dark) .dark\:hover\:text-blue-400:hover {
-                color: inherit !important;
-            }
-        }
+        /* Tailwind CDN dark mode support */
+        /* Ensure dark: classes only apply when .dark is on html */
     </style>
 
     <!-- Dark mode initialization (prevents flash) -->

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

@@ -47,7 +47,7 @@ Custom navbar (extending):
 {% endwith %}
 {% endcomment %}
 
-<header class="bg-white dark:bg-gray-800 shadow-sm border-b border-gray-200 dark:border-gray-700 {% if sticky|default:True %}sticky top-0 z-50{% endif %}">
+<header class="bg-gray-100 dark:bg-gray-800 shadow-lg border-b border-gray-200 dark:border-gray-700 {% if sticky|default:True %}sticky top-0 z-50{% endif %}">
     <div class="{% if full_width %}w-full{% else %}max-w-7xl mx-auto{% endif %} px-4 sm:px-6 lg:px-8">
         <!-- Main navbar row -->
         <div class="flex justify-between h-16">

django_cfg/modules/django_tasks/__init__.py

@@ -4,17 +4,17 @@ Django-CFG Task Service Module.
 Simplified task service for Dramatiq integration with essential functionality.
 """
 
-from .service import DjangoTasks
 from .factory import (
-    get_task_service,
-    reset_task_service,
-    is_task_system_available,
     get_task_health,
+    get_task_service,
     initialize_task_system,
+    is_task_system_available,
+    reset_task_service,
 )
+from .service import DjangoTasks
 from .settings import (
-    generate_dramatiq_settings_from_config,
     extend_constance_config_with_tasks,
+    generate_dramatiq_settings_from_config,
 )
 
 __all__ = [

django_cfg/modules/django_tasks/dramatiq_setup.py

@@ -9,8 +9,8 @@ Usage:
 """
 
 # Import django_dramatiq setup (handles Django initialization)
-import django_dramatiq.setup
 
 # Re-export the broker for Dramatiq CLI
 import dramatiq
+
 broker = dramatiq.get_broker()

django_cfg/modules/django_tasks/factory.py

@@ -4,8 +4,8 @@ Task service factory and utilities.
 Provides singleton instance and utility functions.
 """
 
-from typing import Optional, Dict, Any
 import logging
+from typing import Any, Dict
 
 logger = logging.getLogger(__name__)