django-cfg 1.4.10__py3-none-any.whl → 1.4.11__py3-none-any.whl

django_cfg/modules/django_email/management/commands/test_email.py

@@ -0,0 +1,93 @@
+"""
+Test Email Command
+
+Tests email sending functionality using django_cfg configuration.
+"""
+
+from django.core.management.base import BaseCommand
+from django.contrib.auth import get_user_model
+from django_cfg.modules.django_logging import get_logger
+
+User = get_user_model()
+logger = get_logger('test_email')
+
+
+class Command(BaseCommand):
+    """Command to test email functionality."""
+
+    # Web execution metadata
+    web_executable = True
+    requires_input = False
+    is_destructive = False
+
+    help = "Test email sending functionality"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--email",
+            type=str,
+            help="Email address to send test message to",
+            default="markolofsen@gmail.com",
+        )
+        parser.add_argument(
+            "--subject",
+            type=str,
+            help="Email subject",
+            default="Test Email from UnrealON",
+        )
+        parser.add_argument(
+            "--message",
+            type=str,
+            help="Email message",
+            default="This is a test email from UnrealON system.",
+        )
+
+    def handle(self, *args, **options):
+        email = options["email"]
+        subject = options["subject"]
+        message = options["message"]
+
+        logger.info(f"Starting email test for {email}")
+        self.stdout.write(f"🚀 Testing email service for {email}")
+
+        # Create test user if not exists
+        user, created = User.objects.get_or_create(
+            email=email, defaults={"username": email.split("@")[0], "is_active": True}
+        )
+        if created:
+            self.stdout.write(f"✨ Created test user: {user.username}")
+
+        # Get email service from django-cfg (автоматически настроен!)
+        try:
+            from django_cfg.modules.django_email import DjangoEmailService
+            email_service = DjangoEmailService()
+            
+            # Показать информацию о backend
+            backend_info = email_service.get_backend_info()
+            self.stdout.write(f"\n📧 Backend: {backend_info['backend']}")
+            self.stdout.write(f"📧 Configured: {backend_info['configured']}")
+            
+            self.stdout.write("\n📧 Sending test email with HTML template...")
+            
+            # Отправить письмо с HTML шаблоном
+            result = email_service.send_template(
+                subject=subject,
+                template_name="emails/base_email",
+                context={
+                    'email_title': subject,
+                    'greeting': 'Hello',
+                    'main_text': message,
+                    'project_name': 'Django CFG Sample',
+                    'site_url': 'http://localhost:8000',
+                    'logo_url': 'https://djangocfg.com/favicon.png',
+                    'button_text': 'Visit Website',
+                    'button_url': 'http://localhost:8000',
+                    'secondary_text': 'This is a test email sent from django-cfg management command.',
+                },
+                recipient_list=[email]
+            )
+            
+            self.stdout.write(self.style.SUCCESS(f"✅ Email sent successfully! Result: {result}"))
+            
+        except Exception as e:
+            self.stdout.write(self.style.ERROR(f"❌ Failed to send email: {e}"))

django_cfg/modules/django_logging/django_logger.py

@@ -40,9 +40,9 @@ class DjangoLogger(BaseCfgModule):
         logs_dir.mkdir(parents=True, exist_ok=True)
         djangocfg_logs_dir.mkdir(parents=True, exist_ok=True)
         
-        print(f"[django-cfg] Setting up modular logging:")
-        print(f"  Django logs: {logs_dir / 'django.log'}")
-        print(f"  Django-CFG logs: {djangocfg_logs_dir}/")
+        # print(f"[django-cfg] Setting up modular logging:")
+        # print(f"  Django logs: {logs_dir / 'django.log'}")
+        # print(f"  Django-CFG logs: {djangocfg_logs_dir}/")
         
         # Get debug mode
         try:
@@ -79,7 +79,7 @@ class DjangoLogger(BaseCfgModule):
             root_logger.addHandler(console_handler)
             root_logger.addHandler(django_handler)  # All logs go to django.log
             
-            print(f"[django-cfg] Modular logging configured successfully! Debug: {debug}")
+            # print(f"[django-cfg] Modular logging configured successfully! Debug: {debug}")
             cls._configured = True
             
         except Exception as e:
@@ -139,7 +139,7 @@ class DjangoLogger(BaseCfgModule):
                 logger.addHandler(file_handler)
                 logger.propagate = True  # Also send to parent (django.log)
                 
-                print(f"[django-cfg] Created modular logger: {name} -> {log_file_path}")
+                # print(f"[django-cfg] Created modular logger: {name} -> {log_file_path}")
                 
             except Exception as e:
                 print(f"[django-cfg] ERROR creating modular logger for {name}: {e}")
@@ -189,7 +189,7 @@ def get_logger(name: str = "django_cfg") -> logging.Logger:
                                 
                                 if clean_parts:
                                     auto_name = f"django_cfg.{'.'.join(clean_parts)}"
-                                    print(f"[django-cfg] Auto-detected logger name: {name} -> {auto_name}")
+                                    # print(f"[django-cfg] Auto-detected logger name: {name} -> {auto_name}")
                                     name = auto_name
                         
                         elif module_path.startswith('modules/'):

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

@@ -0,0 +1,167 @@
+"""
+Management command to run Django development server with ngrok tunnel.
+
+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
+
+logger = get_logger('runserver_ngrok')
+
+
+class Command(RunServerCommand):
+    """Enhanced runserver command with ngrok tunnel support."""
+
+    # Web execution metadata
+    web_executable = False
+    requires_input = False
+    is_destructive = False
+
+    help = f'{RunServerCommand.help.rstrip(".")} with ngrok tunnel.'
+    
+    def add_arguments(self, parser):
+        super().add_arguments(parser)
+        parser.add_argument(
+            '--domain',
+            help='Custom ngrok domain (requires paid plan)'
+        )
+        parser.add_argument(
+            '--no-ngrok',
+            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:
+                self.stdout.write("Ngrok not configured or disabled")
+                return super().handle(*args, **options)
+        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()
+                    if current_url and current_url == tunnel_url:
+                        tunnel_ready = True
+                        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.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)
+
+                # Update ALLOWED_HOSTS if needed
+                self._update_allowed_hosts(tunnel_url)
+
+                # Brief success message - detailed info will be shown by startup_display
+                self.stdout.write(
+                    self.style.SUCCESS(f"✅ Ngrok tunnel ready: {tunnel_url}")
+                )
+                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")
+        else:
+            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
+            
+            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_tasks/management/commands/rundramatiq.py

@@ -0,0 +1,254 @@
+"""
+Django management command for running Dramatiq workers.
+
+Based on django_dramatiq.management.commands.rundramatiq with Django-CFG integration.
+Simple, clean, and working approach.
+"""
+
+import argparse
+import importlib
+import multiprocessing
+import os
+import sys
+
+from django.apps import apps
+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_logging import get_logger
+from django_cfg.modules.django_tasks import get_task_service
+
+
+# Default values
+NPROCS = multiprocessing.cpu_count()
+NTHREADS = 8
+
+
+logger = get_logger('rundramatiq')
+
+
+class Command(BaseCommand):
+    # Web execution metadata
+    web_executable = False
+    requires_input = False
+    is_destructive = False
+
+    help = "Run Dramatiq workers with Django-CFG configuration."
+
+    def add_arguments(self, parser):
+        parser.formatter_class = argparse.ArgumentDefaultsHelpFormatter
+        
+        parser.add_argument(
+            "--processes", "-p",
+            default=NPROCS,
+            type=int,
+            help="The number of processes to run",
+        )
+        parser.add_argument(
+            "--threads", "-t",
+            default=NTHREADS,
+            type=int,
+            help="The number of threads per process to use",
+        )
+        parser.add_argument(
+            "--queues", "-Q",
+            nargs="*",
+            type=str,
+            help="Listen to a subset of queues, or all when empty",
+        )
+        parser.add_argument(
+            "--watch",
+            dest="watch_dir",
+            help="Reload workers when changes are detected in the given directory",
+        )
+        parser.add_argument(
+            "--pid-file",
+            type=str,
+            help="Write the PID of the master process to this file",
+        )
+        parser.add_argument(
+            "--log-file",
+            type=str,
+            help="Write all logs to a file, or stderr when empty",
+        )
+        parser.add_argument(
+            "--worker-shutdown-timeout", 
+            type=int, 
+            default=600000,
+            help="Timeout for worker shutdown, in milliseconds"
+        )
+        parser.add_argument(
+            "--dry-run",
+            action="store_true",
+            help="Show configuration without starting workers",
+        )
+
+    def handle(self, watch_dir, processes, threads, verbosity, queues, 
+               pid_file, log_file, worker_shutdown_timeout, dry_run, **options):
+        logger.info("Starting rundramatiq command")
+        
+        # Get task service and validate
+        task_service = get_task_service()
+        if not task_service.is_enabled():
+            self.stdout.write(
+                self.style.ERROR("Task system is not enabled in Django-CFG configuration")
+            )
+            return
+        
+        # Discover task modules
+        tasks_modules = self._discover_tasks_modules()
+        
+        # Show configuration info
+        self.stdout.write(self.style.SUCCESS("Dramatiq Worker Configuration:"))
+        self.stdout.write(f"Processes: {processes}")
+        self.stdout.write(f"Threads: {threads}")
+        if queues:
+            self.stdout.write(f"Queues: {', '.join(queues)}")
+        else:
+            self.stdout.write("Queues: all")
+        
+        self.stdout.write(f"\nDiscovered task modules:")
+        for module in tasks_modules:
+            self.stdout.write(f"  - {module}")
+        
+        # If dry run, show command and exit
+        if dry_run:
+            executable_name = "dramatiq"
+            
+            process_args = [
+                executable_name,
+                "django_cfg.modules.django_tasks.dramatiq_setup",  # Broker module
+                "--processes", str(processes),
+                "--threads", str(threads),
+                "--worker-shutdown-timeout", str(worker_shutdown_timeout),
+            ]
+            
+            if watch_dir:
+                process_args.extend(["--watch", watch_dir])
+            
+            verbosity_args = ["-v"] * (verbosity - 1)
+            process_args.extend(verbosity_args)
+            
+            if queues:
+                process_args.extend(["--queues"] + queues)
+            
+            if pid_file:
+                process_args.extend(["--pid-file", pid_file])
+            
+            if log_file:
+                process_args.extend(["--log-file", log_file])
+            
+            # Add task modules (broker module is already first in tasks_modules)
+            process_args.extend(tasks_modules)
+            
+            self.stdout.write(f"\nCommand that would be executed:")
+            self.stdout.write(f'  {" ".join(process_args)}')
+            return
+        
+        # Show startup info
+        self.stdout.write(self.style.SUCCESS("\nStarting Dramatiq workers..."))
+        
+        # Build dramatiq command
+        executable_name = "dramatiq"
+        executable_path = self._resolve_executable(executable_name)
+        
+        # Build process arguments exactly like django_dramatiq
+        process_args = [
+            executable_name,
+            "django_cfg.modules.django_tasks.dramatiq_setup",  # Broker module
+            "--processes", str(processes),
+            "--threads", str(threads),
+            "--worker-shutdown-timeout", str(worker_shutdown_timeout),
+        ]
+        
+        # Add watch directory if specified
+        if watch_dir:
+            process_args.extend(["--watch", watch_dir])
+        
+        # Add verbosity
+        verbosity_args = ["-v"] * (verbosity - 1)
+        process_args.extend(verbosity_args)
+        
+        # Add queues if specified
+        if queues:
+            process_args.extend(["--queues"] + queues)
+        
+        # Add PID file if specified
+        if pid_file:
+            process_args.extend(["--pid-file", pid_file])
+        
+        # Add log file if specified
+        if log_file:
+            process_args.extend(["--log-file", log_file])
+        
+        # Add task modules (broker module is already first in tasks_modules)
+        process_args.extend(tasks_modules)
+        
+        self.stdout.write(f'Running dramatiq: "{" ".join(process_args)}"\n')
+        
+        # Ensure DJANGO_SETTINGS_MODULE is set for worker processes
+        if not os.environ.get('DJANGO_SETTINGS_MODULE'):
+            if hasattr(settings, 'SETTINGS_MODULE'):
+                os.environ['DJANGO_SETTINGS_MODULE'] = settings.SETTINGS_MODULE
+            else:
+                # Try to detect from manage.py or current settings
+                import django
+                from django.conf import settings as django_settings
+                if hasattr(django_settings, '_wrapped') and hasattr(django_settings._wrapped, '__module__'):
+                    module_name = django_settings._wrapped.__module__
+                    os.environ['DJANGO_SETTINGS_MODULE'] = module_name
+                else:
+                    self.stdout.write(
+                        self.style.WARNING("Could not detect DJANGO_SETTINGS_MODULE")
+                    )
+        
+        # Use os.execvp like django_dramatiq to preserve environment
+        if sys.platform == "win32":
+            import subprocess
+            command = [executable_path] + process_args[1:]
+            sys.exit(subprocess.run(command))
+        
+        os.execvp(executable_path, process_args)
+
+    def _discover_tasks_modules(self):
+        """Discover task modules like django_dramatiq does."""
+        # Always include our broker setup module first
+        tasks_modules = ["django_cfg.modules.django_tasks.dramatiq_setup"]
+        
+        # Get task service for configuration
+        task_service = get_task_service()
+        
+        # Try to get task modules from Django-CFG config
+        if task_service.config and task_service.config.auto_discover_tasks:
+            discovered = task_service.discover_tasks()
+            for module_name in discovered:
+                self.stdout.write(f"Discovered tasks module: '{module_name}'")
+                tasks_modules.append(module_name)
+        
+        # Fallback: use django_dramatiq discovery logic
+        if len(tasks_modules) == 1:  # Only broker module found
+            task_module_names = getattr(settings, "DRAMATIQ_AUTODISCOVER_MODULES", ("tasks",))
+            
+            for app_config in apps.get_app_configs():
+                for task_module in task_module_names:
+                    if module_has_submodule(app_config.module, task_module):
+                        module_name = f"{app_config.name}.{task_module}"
+                        try:
+                            importlib.import_module(module_name)
+                            self.stdout.write(f"Discovered tasks module: '{module_name}'")
+                            tasks_modules.append(module_name)
+                        except ImportError:
+                            # Module exists but has import errors, skip it
+                            pass
+        
+        return tasks_modules
+
+    def _resolve_executable(self, exec_name):
+        """Resolve executable path like django_dramatiq does."""
+        bin_dir = os.path.dirname(sys.executable)
+        if bin_dir:
+            for d in [bin_dir, os.path.join(bin_dir, "Scripts")]:
+                exec_path = os.path.join(d, exec_name)
+                if os.path.isfile(exec_path):
+                    return exec_path
+        return exec_name