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

django_cfg/management/commands/superuser.py

@@ -1,302 +1,22 @@
 """
-Superuser Command for Django Config Toolkit
-Enhanced superuser creation with validation and configuration.
-"""
-
-import os
-import getpass
-from pathlib import Path
-from django.core.management.base import BaseCommand
-from django.core.management import call_command
-from django.contrib.auth import get_user_model
-from django.core.validators import validate_email
-from django.core.exceptions import ValidationError
-from django.conf import settings
-import questionary
-from datetime import datetime
-from django_cfg.modules.django_logging import get_logger
-
-User = get_user_model()
-
-
-logger = get_logger('superuser')
-
-class Command(BaseCommand):
-    # Web execution metadata
-    web_executable = False
-    requires_input = True
-    is_destructive = False
-
-    help = 'Create a superuser with enhanced validation and configuration'
+Django-CFG wrapper for superuser command.
 
-    def add_arguments(self, parser):
-        parser.add_argument(
-            '--username',
-            type=str,
-            help='Username for superuser'
-        )
-        parser.add_argument(
-            '--email',
-            type=str,
-            help='Email for superuser'
-        )
-        parser.add_argument(
-            '--password',
-            type=str,
-            help='Password for superuser'
-        )
-        parser.add_argument(
-            '--first-name',
-            type=str,
-            help='First name for superuser'
-        )
-        parser.add_argument(
-            '--last-name',
-            type=str,
-            help='Last name for superuser'
-        )
-        parser.add_argument(
-            '--interactive',
-            action='store_true',
-            help='Run in interactive mode'
-        )
+This is a simple alias for django_admin.management.commands.superuser.
+All logic is in django_admin module.
 
-    def handle(self, *args, **options):
-        logger.info("Starting superuser command")
-        if options['interactive'] or not any([options['username'], options['email'], options['password']]):
-            self.create_superuser_interactive()
-        else:
-            self.create_superuser_non_interactive(options)
-
-    def create_superuser_interactive(self):
-        """Create superuser interactively"""
-        self.stdout.write(self.style.SUCCESS('\n👑 Superuser Creation Tool - Django Config Toolkit\n'))
-        
-        # Check if superuser already exists
-        if User.objects.filter(is_superuser=True).exists():
-            self.stdout.write(self.style.WARNING('⚠️  Superuser already exists'))
-            overwrite = questionary.confirm('Do you want to create another superuser?').ask()
-            if not overwrite:
-                self.stdout.write('Goodbye! 👋')
-                return
-
-        # Get user details
-        user_data = self.get_user_details_interactive()
-        
-        # Validate data
-        if not self.validate_user_data(user_data):
-            return
-        
-        # Create superuser
-        self.create_superuser(user_data)
-
-    def create_superuser_non_interactive(self, options):
-        """Create superuser non-interactively"""
-        user_data = {
-            'username': options['username'],
-            'email': options['email'],
-            'password': options['password'],
-            'first_name': options['first_name'] or '',
-            'last_name': options['last_name'] or '',
-        }
-        
-        # Validate required fields
-        if not all([user_data['username'], user_data['email'], user_data['password']]):
-            self.stdout.write(self.style.ERROR('❌ Username, email, and password are required'))
-            return
-        
-        # Validate data
-        if not self.validate_user_data(user_data):
-            return
-        
-        # Create superuser
-        self.create_superuser(user_data)
-
-    def get_user_details_interactive(self):
-        """Get user details interactively"""
-        user_data = {}
-        
-        # Username
-        while True:
-            username = questionary.text('Username:').ask()
-            if not username:
-                self.stdout.write(self.style.ERROR('❌ Username is required'))
-                continue
-            
-            if User.objects.filter(username=username).exists():
-                self.stdout.write(self.style.ERROR('❌ Username already exists'))
-                continue
-            
-            user_data['username'] = username
-            break
-        
-        # Email
-        while True:
-            email = questionary.text('Email:').ask()
-            if not email:
-                self.stdout.write(self.style.ERROR('❌ Email is required'))
-                continue
-            
-            try:
-                validate_email(email)
-            except ValidationError:
-                self.stdout.write(self.style.ERROR('❌ Invalid email format'))
-                continue
-            
-            if User.objects.filter(email=email).exists():
-                self.stdout.write(self.style.ERROR('❌ Email already exists'))
-                continue
-            
-            user_data['email'] = email
-            break
-        
-        # Password
-        while True:
-            password = questionary.password('Password:').ask()
-            if not password:
-                self.stdout.write(self.style.ERROR('❌ Password is required'))
-                continue
-            
-            if len(password) < 8:
-                self.stdout.write(self.style.WARNING('⚠️  Password should be at least 8 characters'))
-                confirm = questionary.confirm('Continue with weak password?').ask()
-                if not confirm:
-                    continue
-            
-            confirm_password = questionary.password('Confirm password:').ask()
-            if password != confirm_password:
-                self.stdout.write(self.style.ERROR('❌ Passwords do not match'))
-                continue
-            
-            user_data['password'] = password
-            break
-        
-        # Optional fields
-        user_data['first_name'] = questionary.text('First name (optional):').ask() or ''
-        user_data['last_name'] = questionary.text('Last name (optional):').ask() or ''
-        
-        return user_data
-
-    def validate_user_data(self, user_data):
-        """Validate user data"""
-        errors = []
-        
-        # Check required fields
-        if not user_data.get('username'):
-            errors.append('Username is required')
-        
-        if not user_data.get('email'):
-            errors.append('Email is required')
-        
-        if not user_data.get('password'):
-            errors.append('Password is required')
-        
-        # Validate email format
-        if user_data.get('email'):
-            try:
-                validate_email(user_data['email'])
-            except ValidationError:
-                errors.append('Invalid email format')
-        
-        # Check if user already exists
-        if user_data.get('username') and User.objects.filter(username=user_data['username']).exists():
-            errors.append('Username already exists')
-        
-        if user_data.get('email') and User.objects.filter(email=user_data['email']).exists():
-            errors.append('Email already exists')
-        
-        # Password strength
-        if user_data.get('password') and len(user_data['password']) < 8:
-            errors.append('Password should be at least 8 characters')
-        
-        if errors:
-            self.stdout.write(self.style.ERROR('❌ Validation errors:'))
-            for error in errors:
-                self.stdout.write(f'   - {error}')
-            return False
-        
-        return True
+Usage:
+    python manage.py superuser
+    python manage.py superuser --interactive
+    python manage.py superuser --username admin --email admin@example.com --password secret
+"""
 
-    def create_superuser(self, user_data):
-        """Create the superuser"""
-        try:
-            # Create user
-            user = User.objects.create_user(
-                username=user_data['username'],
-                email=user_data['email'],
-                password=user_data['password'],
-                first_name=user_data['first_name'],
-                last_name=user_data['last_name'],
-                is_staff=True,
-                is_superuser=True,
-                is_active=True
-            )
-            
-            # Save user details to file
-            self.save_superuser_details(user, user_data['password'])
-            
-            self.stdout.write(self.style.SUCCESS(f'✅ Superuser created successfully!'))
-            self.stdout.write(f'👤 Username: {user.username}')
-            self.stdout.write(f'📧 Email: {user.email}')
-            self.stdout.write(f'👑 Is Superuser: {user.is_superuser}')
-            self.stdout.write(f'🔧 Is Staff: {user.is_staff}')
-            self.stdout.write(f'✅ Is Active: {user.is_active}')
-            
-            # Show next steps
-            self.show_next_steps()
-            
-        except Exception as e:
-            self.stdout.write(self.style.ERROR(f'❌ Error creating superuser: {e}'))
+from django_cfg.modules.django_admin.management.commands.superuser import Command as SuperuserCommand
 
-    def save_superuser_details(self, user, password):
-        """Save superuser details to file"""
-        # Create superusers directory
-        superusers_dir = Path('superusers')
-        superusers_dir.mkdir(exist_ok=True)
-        
-        # Create details file
-        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-        filename = f"superuser_{user.username}_{timestamp}.txt"
-        filepath = superusers_dir / filename
-        
-        with open(filepath, 'w') as f:
-            f.write(f"Superuser Details\n")
-            f.write(f"================\n\n")
-            f.write(f"Username: {user.username}\n")
-            f.write(f"Email: {user.email}\n")
-            f.write(f"First Name: {user.first_name}\n")
-            f.write(f"Is Superuser: {user.is_superuser}\n")
-            f.write(f"Is Staff: {user.is_staff}\n")
-            f.write(f"Is Active: {user.is_active}\n")
-            f.write(f"Date Created: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
-            f.write(f"\n⚠️  IMPORTANT: Store this password securely!\n")
-            f.write(f"Password: {password}\n")
-        
-        self.stdout.write(f'💾 Superuser details saved to: {filepath}')
 
-    def show_next_steps(self):
-        """Show next steps after creating superuser"""
-        self.stdout.write(self.style.SUCCESS('\n🎉 Next Steps:'))
-        self.stdout.write('1. 🚀 Start your Django server: python manage.py runserver')
-        self.stdout.write('2. 🌐 Visit Django admin: http://localhost:8000/admin/')
-        self.stdout.write('3. 🔑 Login with your superuser credentials')
-        self.stdout.write('4. ⚙️  Configure your application settings')
-        self.stdout.write('5. 📚 Read the Django Config Toolkit documentation')
-        
-        # Show health check
-        self.stdout.write('\n🔍 Health Check:')
-        try:
-            call_command('check', verbosity=0)
-            self.stdout.write('✅ Django configuration is valid')
-        except Exception as e:
-            self.stdout.write(f'⚠️  Django configuration issues: {e}')
+class Command(SuperuserCommand):
+    """
+    Alias for superuser command.
 
-    def check_existing_superusers(self):
-        """Check existing superusers"""
-        superusers = User.objects.filter(is_superuser=True)
-        if superusers.exists():
-            self.stdout.write(self.style.WARNING(f'⚠️  Found {superusers.count()} existing superuser(s):'))
-            for user in superusers:
-                self.stdout.write(f'   - {user.username} ({user.email})')
-            return True
-        return False
+    Simply inherits from SuperuserCommand without any changes.
+    """
+    pass

django_cfg/management/commands/task_clear.py

@@ -1,226 +1,23 @@
 """
-Django management command for clearing task queues.
+Django-CFG wrapper for task_clear command.
 
-This command provides utilities for clearing failed tasks,
-specific queues, or all tasks from the Dramatiq system.
-"""
+This is a simple alias for django_tasks.management.commands.task_clear.
+All logic is in django_tasks module.
 
-from django.core.management.base import BaseCommand, CommandError
-from django.conf import settings
-from typing import Any, Optional, List
-import logging
-from django_cfg.modules.django_logging import get_logger
+Usage:
+    python manage.py task_clear
+    python manage.py task_clear --queue default
+    python manage.py task_clear --failed-only
+    python manage.py task_clear --confirm
+"""
 
-logger = get_logger('task_clear')
+from django_cfg.modules.django_tasks.management.commands.task_clear import Command as TaskClearCommand
 
 
-class Command(BaseCommand):
+class Command(TaskClearCommand):
     """
-    Clear tasks from Dramatiq queues.
+    Alias for task_clear command.
 
-    Provides options to:
-    - Clear all tasks from specific queues
-    - Clear only failed tasks
-    - Clear all tasks from all queues
+    Simply inherits from TaskClearCommand without any changes.
     """
-
-    # Web execution metadata
-    web_executable = False
-    requires_input = True
-    is_destructive = True
-
-    help = "Clear tasks from Dramatiq queues"
-    
-    def add_arguments(self, parser):
-        """Add command line arguments."""
-        parser.add_argument(
-            "--queue",
-            type=str,
-            help="Specific queue to clear (default: all queues)",
-        )
-        parser.add_argument(
-            "--failed-only",
-            action="store_true",
-            help="Clear only failed tasks",
-        )
-        parser.add_argument(
-            "--confirm",
-            action="store_true",
-            help="Skip confirmation prompt",
-        )
-        parser.add_argument(
-            "--dry-run",
-            action="store_true",
-            help="Show what would be cleared without actually clearing",
-        )
-    
-    def handle(self, *args, **options):
-        """Handle the command execution."""
-        logger.info("Starting task_clear command")
-        
-        try:
-            # Import here to avoid issues if dramatiq is not installed
-            from django_cfg.modules.django_tasks import get_task_service
-            
-            # Get task service
-            task_service = get_task_service()
-            
-            # Check if task system is enabled
-            if not task_service.is_enabled():
-                raise CommandError(
-                    "Task system is not enabled. "
-                    "Please configure 'tasks' in your Django-CFG configuration."
-                )
-            
-            # Get task manager
-            manager = task_service.manager
-            if not manager:
-                raise CommandError("Task manager not available")
-            
-            # Get configuration
-            config = task_service.config
-            if not config:
-                raise CommandError("Task configuration not available")
-            
-            # Determine queues to clear
-            if options.get("queue"):
-                queues_to_clear = [options["queue"]]
-                # Validate queue exists
-                if options["queue"] not in config.get_effective_queues():
-                    self.stdout.write(
-                        self.style.WARNING(
-                            f"Queue '{options['queue']}' not in configured queues: "
-                            f"{', '.join(config.get_effective_queues())}"
-                        )
-                    )
-            else:
-                queues_to_clear = config.get_effective_queues()
-            
-            # Show what will be cleared
-            self._show_clear_plan(queues_to_clear, options)
-            
-            if options["dry_run"]:
-                self.stdout.write(
-                    self.style.SUCCESS("Dry run completed - no tasks were cleared")
-                )
-                return
-            
-            # Confirm action
-            if not options["confirm"]:
-                if not self._confirm_clear(queues_to_clear, options):
-                    self.stdout.write("Operation cancelled")
-                    return
-            
-            # Perform clearing
-            self._clear_queues(manager, queues_to_clear, options)
-            
-        except ImportError:
-            raise CommandError(
-                "Dramatiq dependencies not installed. "
-                "Install with: pip install django-cfg[tasks]"
-            )
-        except Exception as e:
-            logger.exception("Failed to clear tasks")
-            raise CommandError(f"Failed to clear tasks: {e}")
-    
-    def _show_clear_plan(self, queues: List[str], options):
-        """Show what will be cleared."""
-        self.stdout.write(
-            self.style.SUCCESS("=== Clear Plan ===")
-        )
-        
-        if options.get("failed_only"):
-            self.stdout.write("Action: Clear FAILED tasks only")
-        else:
-            self.stdout.write("Action: Clear ALL tasks")
-        
-        self.stdout.write(f"Queues: {', '.join(queues)}")
-        
-        # Get current queue statistics
-        try:
-            from django_cfg.modules.django_tasks import get_task_service
-            task_service = get_task_service()
-            manager = task_service.manager
-            
-            if manager:
-                queue_stats = manager.get_queue_stats()
-                
-                self.stdout.write("\nCurrent Queue Statistics:")
-                for stat in queue_stats:
-                    if stat["name"] in queues:
-                        name = stat["name"]
-                        pending = stat.get("pending", 0)
-                        failed = stat.get("failed", 0)
-                        
-                        if options.get("failed_only"):
-                            self.stdout.write(f"  {name}: {failed} failed tasks")
-                        else:
-                            total = pending + stat.get("running", 0) + failed
-                            self.stdout.write(f"  {name}: {total} total tasks")
-        except Exception as e:
-            self.stdout.write(f"Could not get queue statistics: {e}")
-        
-        self.stdout.write()
-    
-    def _confirm_clear(self, queues: List[str], options) -> bool:
-        """Confirm the clear operation with user."""
-        if options.get("failed_only"):
-            action = "clear FAILED tasks"
-        else:
-            action = "clear ALL tasks"
-        
-        queue_list = ", ".join(queues)
-        
-        self.stdout.write(
-            self.style.WARNING(
-                f"This will {action} from queues: {queue_list}"
-            )
-        )
-        
-        response = input("Are you sure? [y/N]: ").lower().strip()
-        return response in ["y", "yes"]
-    
-    def _clear_queues(self, manager, queues: List[str], options):
-        """Clear the specified queues."""
-        cleared_count = 0
-        
-        self.stdout.write(
-            self.style.SUCCESS("Starting queue clearing...")
-        )
-        
-        for queue_name in queues:
-            try:
-                self.stdout.write(f"Clearing queue: {queue_name}")
-                
-                if options.get("failed_only"):
-                    # Clear only failed tasks
-                    # TODO: Implement failed task clearing
-                    # This would require specific Dramatiq broker methods
-                    count = 0  # Placeholder
-                    self.stdout.write(f"  Cleared {count} failed tasks")
-                else:
-                    # Clear all tasks
-                    success = manager.clear_queue(queue_name)
-                    if success:
-                        # TODO: Get actual count of cleared tasks
-                        count = 0  # Placeholder
-                        self.stdout.write(f"  Cleared {count} tasks")
-                        cleared_count += count
-                    else:
-                        self.stdout.write(
-                            self.style.ERROR(f"  Failed to clear queue: {queue_name}")
-                        )
-                
-            except Exception as e:
-                self.stdout.write(
-                    self.style.ERROR(f"  Error clearing queue {queue_name}: {e}")
-                )
-        
-        if cleared_count > 0:
-            self.stdout.write(
-                self.style.SUCCESS(f"Successfully cleared {cleared_count} tasks")
-            )
-        else:
-            self.stdout.write(
-                self.style.WARNING("No tasks were cleared")
-            )
+    pass