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

django_cfg/management/commands/migrator.py

@@ -1,403 +1,20 @@
 """
-Smart Migration Command for Django Config Toolkit
-Simple and reliable migration for all databases.
-"""
-
-import os
-from pathlib import Path
-from django.core.management.base import BaseCommand
-from django.core.management import call_command
-from django.apps import apps
-from django.db import connections
-from django.db.migrations.recorder import MigrationRecorder
-from django.conf import settings
-import questionary
-from datetime import datetime
-from django_cfg.core.config import DEFAULT_APPS
-from django_cfg.modules.django_logging import get_logger
-
-logger = get_logger('migrator')
-
-
-class Command(BaseCommand):
-    # Web execution metadata
-    web_executable = False
-    requires_input = True
-    is_destructive = True
-
-    help = "Smart migration command with interactive menu for multiple databases"
-
-    def add_arguments(self, parser):
-        parser.add_argument("--auto", action="store_true", help="Run automatic migration without prompts")
-        parser.add_argument("--database", type=str, help="Migrate specific database only")
-        parser.add_argument("--app", type=str, help="Migrate specific app only")
-
-    def handle(self, *args, **options):
-        if options["auto"]:
-            self.run_automatic_migration()
-        elif options["database"]:
-            self.migrate_database(options["database"])
-        elif options["app"]:
-            self.migrate_app(options["app"])
-        else:
-            self.show_interactive_menu()
-
-    def show_interactive_menu(self):
-        """Show interactive menu with options"""
-        self.stdout.write(self.style.SUCCESS("\n🚀 Smart Migration Tool - Django Config Toolkit\n"))
-
-        databases = self.get_all_database_names()
-
-        choices = [
-            questionary.Choice("🔄 Run Full Migration (All Databases)", value="full"),
-            questionary.Choice("📝 Create Migrations Only", value="makemigrations"),
-            questionary.Choice("🔍 Show Database Status", value="status"),
-            questionary.Choice("⚙️  Show Django Config Info", value="config"),
-            questionary.Choice("❌ Exit", value="exit"),
-        ]
-
-        # Add individual database options
-        for db_name in databases:
-            display_name = f"📊 Migrate {db_name.title()} Database Only"
-            choices.insert(-1, questionary.Choice(display_name, value=f"migrate_{db_name}"))
-
-        choice = questionary.select("Select an option:", choices=choices).ask()
-
-        if choice == "full":
-            self.run_full_migration()
-        elif choice == "makemigrations":
-            self.create_migrations()
-        elif choice == "status":
-            self.show_database_status()
-        elif choice == "config":
-            self.show_config_info()
-        elif choice == "exit":
-            self.stdout.write("Goodbye! 👋")
-            return
-        elif choice.startswith("migrate_"):
-            db_name = choice.replace("migrate_", "")
-            self.migrate_database(db_name)
-
-    def run_full_migration(self):
-        """Run migration for all databases"""
-        self.stdout.write(self.style.SUCCESS("🔄 Starting full migration..."))
-
-        # First migrate default database
-        self.stdout.write("📊 Migrating default database...")
-        self.migrate_database("default")
-
-        # Then migrate other databases (excluding default)
-        databases = self.get_all_database_names()
-        for db_name in databases:
-            if db_name != "default":
-                self.stdout.write(f"🔄 Migrating {db_name}...")
-                self.migrate_database(db_name)
-
-        self.stdout.write(self.style.SUCCESS("✅ Full migration completed!"))
-
-    def run_automatic_migration(self):
-        """Run automatic migration for all databases"""
-        self.stdout.write(self.style.SUCCESS("🚀 Running automatic migration..."))
-
-        # Create migrations
-        self.create_migrations()
-
-        # Run full migration
-        self.run_full_migration()
-        
-        # Always migrate constance (required for django-cfg)
-        self.migrate_constance_if_needed()
-
-    def create_migrations(self):
-        """Create migrations for all apps"""
-        self.stdout.write(self.style.SUCCESS("📝 Creating migrations..."))
-
-        try:
-            # First try global makemigrations
-            call_command("makemigrations", verbosity=1)
-            
-            # Then try for each app that has models but no migrations
-            all_apps = self.get_all_installed_apps()
-            for app in all_apps:
-                if self.app_has_models(app) and not self.app_has_migrations(app):
-                    try:
-                        self.stdout.write(f"  📝 Creating migrations for {app}...")
-                        call_command("makemigrations", app, verbosity=1)
-                    except Exception as e:
-                        self.stdout.write(self.style.WARNING(f"  ⚠️  Could not create migrations for {app}: {e}"))
-            
-            self.stdout.write(self.style.SUCCESS("✅ Migrations created"))
-        except Exception as e:
-            self.stdout.write(self.style.WARNING(f"⚠️  Warning creating migrations: {e}"))
-
-    def _raise_system_exit(self, message):
-        self.stdout.write(self.style.ERROR(f"❌ {message}"))
-        logger.error(message)
-        # raise SystemExit(1)
-
-    def migrate_database(self, db_name):
-        """Migrate specific database"""
-        try:
-            self.stdout.write(f"🔄 Migrating {db_name}...")
-
-            # Get apps for this database
-            apps = self.get_apps_for_database(db_name)
-
-            # Debug info
-            self.stdout.write(f"  📋 Apps for {db_name}: {apps}")
-
-            if not apps:
-                self.stdout.write(self.style.WARNING(f"  ⚠️  No apps configured for {db_name}"))
-                return
-
-            # make migrations for all apps
-            self.create_migrations()
-
-            # Migrate each app
-            for app in apps:
-                try:
-                    # Skip apps without migrations
-                    if not self.app_has_migrations(app):
-                        # self.stdout.write(f"  ⚠️  Skipping {app} - no migrations")
-                        continue
-
-                    self.stdout.write(f"  📦 Migrating {app}...")
-                    call_command("migrate", app, database=db_name, verbosity=1)
-                except Exception as e:
-                    self._raise_system_exit(f"Migration failed for {app} on {db_name}: {e}")
-
-            self.stdout.write(self.style.SUCCESS(f"✅ {db_name} migration completed!"))
-
-        except Exception as e:
-            self._raise_system_exit(f"Error migrating {db_name}: {e}")
-
-    def migrate_constance_if_needed(self):
-        """Always migrate constance app if it's installed"""
-        try:
-            # Check if constance is in INSTALLED_APPS
-            if 'constance' in settings.INSTALLED_APPS:
-                self.stdout.write(self.style.SUCCESS("🔧 Migrating constance (django-cfg requirement)..."))
-                
-                # Try to migrate constance on default database
-                try:
-                    call_command("migrate", "constance", database="default", verbosity=1)
-                    self.stdout.write(self.style.SUCCESS("✅ Constance migration completed!"))
-                except Exception as e:
-                    self._raise_system_exit(f"Constance migration failed: {e}")
-            else:
-                self.stdout.write(self.style.WARNING("⚠️  Constance not found in INSTALLED_APPS"))
-                
-        except Exception as e:
-            self._raise_system_exit(f"Could not migrate constance: {e}")
-
-    def migrate_app(self, app_name):
-        """Migrate specific app across all databases"""
-        self.stdout.write(f"🔄 Migrating app {app_name}...")
-
-        databases = self.get_all_database_names()
-        for db_name in databases:
-            apps = self.get_apps_for_database(db_name)
-            if app_name in apps:
-                self.stdout.write(f"  📊 Migrating {app_name} on {db_name}...")
-                try:
-                    call_command("migrate", app_name, database=db_name, verbosity=1)
-                except Exception as e:
-                    self._raise_system_exit(f"Migration failed for {app_name} on {db_name}: {e}")
+Django-CFG wrapper for migrator command.
 
-    def show_database_status(self):
-        """Show status of all databases and their apps"""
-        self.stdout.write(self.style.SUCCESS("\n📊 Database Status Report\n"))
+This is a simple alias for django_admin.management.commands.migrator.
+All logic is in django_admin module.
 
-        # Get database info from Django settings
-        db_info = self.get_database_info()
-        databases = self.get_all_database_names()
-
-        for db_name in databases:
-            self.stdout.write(f"\n🗄️  Database: {db_name}")
-
-            # Show database info from Django settings
-            if db_name in db_info:
-                info = db_info[db_name]
-                self.stdout.write(f'  🔧 Engine: {info["engine"]}')
-                self.stdout.write(f'  🔗 Name: {info["name"]}')
-
-            # Test connection
-            try:
-                with connections[db_name].cursor() as cursor:
-                    cursor.execute("SELECT 1")
-                self.stdout.write(f"  ✅ Connection: OK")
-            except Exception as e:
-                self.stdout.write(f"  ❌ Connection: FAILED - {e}")
-
-            # Show apps
-            apps = self.get_apps_for_database(db_name)
-            if apps:
-                self.stdout.write(f'  📦 Apps: {", ".join(apps)}')
-            else:
-                self.stdout.write(f"  📦 Apps: None configured")
-
-    def show_config_info(self):
-        """Show Django configuration information"""
-        self.stdout.write(self.style.SUCCESS("\n⚙️  Django Configuration Information\n"))
-
-        try:
-            # Environment info
-            self.stdout.write(f'🌍 Environment: {getattr(settings, "ENVIRONMENT", "unknown")}')
-            self.stdout.write(f"🔧 Debug: {settings.DEBUG}")
-
-            # Database info
-            databases = settings.DATABASES
-            self.stdout.write(f"🗄️ Databases: {len(databases)}")
-
-            for db_name, db_config in databases.items():
-                engine = db_config.get("ENGINE", "unknown")
-                name = db_config.get("NAME", "unknown")
-                self.stdout.write(f"  📊 {db_name}: {engine} -> {name}")
-
-            # Multiple databases
-            if len(databases) > 1:
-                self.stdout.write(f"📊 Multiple Databases: Yes")
-
-                # Show routing rules
-                routing_rules = getattr(settings, "DATABASE_ROUTING_RULES", {})
-                if routing_rules:
-                    self.stdout.write(f"  🔀 Routing Rules:")
-                    for app, db in routing_rules.items():
-                        self.stdout.write(f"    - {app} → {db}")
-                else:
-                    self.stdout.write(f"  🔀 Routing Rules: None configured")
-            else:
-                self.stdout.write(f"📊 Multiple Databases: No")
-
-            # Other settings
-            self.stdout.write(f'🔑 Secret Key: {"*" * 20}...')
-            self.stdout.write(f"🌐 Allowed Hosts: {settings.ALLOWED_HOSTS}")
-            self.stdout.write(f"📦 Installed Apps: {len(settings.INSTALLED_APPS)}")
-
-        except Exception as e:
-            self._raise_system_exit(f"Error getting Django config info: {e}")
-
-    def get_apps_for_database(self, db_name: str):
-        """Get apps for specific database with smart logic for default"""
-        if db_name == "default":
-            # For default database, get all apps that are not in other databases
-            all_apps = self.get_all_installed_apps()
-            apps_in_other_dbs = self.get_apps_in_other_databases()
-            return [app for app in all_apps if app not in apps_in_other_dbs]
-        else:
-            # For other databases, use configured apps from routing rules
-            routing_rules = getattr(settings, "DATABASE_ROUTING_RULES", {})
-
-            # Routing rules are now in Django settings
-            pass
-
-            return [app for app, db in routing_rules.items() if db == db_name]
-
-    def get_all_installed_apps(self):
-        """Get all installed Django apps by checking for apps.py files."""
-        apps_list = []
-
-        # Get all Django app configs
-        for app_config in apps.get_app_configs():
-            app_label = app_config.label
-            app_path = Path(app_config.path)
-
-            # Check if apps.py exists in the app directory
-            apps_py_path = app_path / "apps.py"
-            if apps_py_path.exists():
-                if app_label not in DEFAULT_APPS:
-                    apps_list.append(app_label)
-                continue
-
-            # Fallback: check if it's a standard Django app (has models.py or admin.py)
-            if (app_path / "models.py").exists() or (app_path / "admin.py").exists():
-                apps_list.append(app_label)
-
-        return apps_list
-
-    def get_apps_in_other_databases(self) -> set:
-        """Get all apps that are configured for non-default databases."""
-        routing_rules = getattr(settings, "DATABASE_ROUTING_RULES", {})
-
-        # Routing rules are now in Django settings
-        pass
-
-        return set(routing_rules.keys())
-
-    def get_all_database_names(self):
-        """Get all database names."""
-        return list(connections.databases.keys())
-
-    def get_database_info(self):
-        """Get database information from Django settings"""
-        try:
-            db_info = {}
-
-            # Get database info from Django settings
-            for db_name, db_config in settings.DATABASES.items():
-                db_info[db_name] = {"name": db_config.get("NAME", "unknown"), "engine": db_config.get("ENGINE", "unknown"), "host": db_config.get("HOST", ""), "port": db_config.get("PORT", ""), "apps": []}  # Will be populated by routing logic
-
-            return db_info
-
-        except Exception as e:
-            self.stdout.write(self.style.WARNING(f"⚠️  Error getting database info: {e}"))
-            return {}
-
-    def app_has_migrations(self, app_label: str) -> bool:
-        """Simple check if an app has migrations."""
-        try:
-            # Get the app config
-            app_config = apps.get_app_config(app_label)
-            if not app_config:
-                return False
-
-            # Check if migrations directory exists and has files
-            migrations_dir = Path(app_config.path) / "migrations"
-            if not migrations_dir.exists():
-                return False
-
-            # Check if there are any migration files (excluding __init__.py)
-            migration_files = [f for f in migrations_dir.glob("*.py") if f.name != "__init__.py"]
-
-            # Also check if there are any applied migrations in the database
-            # Check all databases for this app's migrations
-            for db_name in connections.databases.keys():
-                try:
-                    recorder = MigrationRecorder(connections[db_name])
-                    applied_migrations = recorder.migration_qs.filter(app=app_label)
-                    if applied_migrations.exists():
-                        return True
-                except Exception:
-                    continue
-
-            # If no applied migrations found, check if there are migration files
-            return len(migration_files) > 0
-
-        except Exception:
-            # Silently return False for apps that don't exist or have issues
-            return False
+Usage:
+    python manage.py migrator
+"""
 
-    def app_has_models(self, app_label: str) -> bool:
-        """Check if an app has models defined."""
-        try:
-            # Get the app config
-            app_config = apps.get_app_config(app_label)
-            if not app_config:
-                return False
+from django_cfg.modules.django_admin.management.commands.migrator import Command as MigratorCommand
 
-            # Check if models.py exists and has content
-            models_file = Path(app_config.path) / "models.py"
-            if models_file.exists():
-                # Read the file and check if it has model definitions
-                content = models_file.read_text()
-                # Simple check for model definitions
-                if "class " in content and "models.Model" in content:
-                    return True
 
-            # Also check if the app has any registered models
-            models = app_config.get_models()
-            return len(models) > 0
+class Command(MigratorCommand):
+    """
+    Alias for migrator command.
 
-        except Exception:
-            # Silently return False for apps that don't exist or have issues
-            return False
+    Simply inherits from MigratorCommand without any changes.
+    """
+    pass

django_cfg/management/commands/rundramatiq.py

@@ -1,254 +1,22 @@
 """
-Django management command for running Dramatiq workers.
+Django-CFG wrapper for rundramatiq command.
 
-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
+This is a simple alias for django_tasks.management.commands.rundramatiq.
+All logic is in django_tasks module.
 
+Usage:
+    python manage.py rundramatiq
+    python manage.py rundramatiq --processes 4 --threads 8
+    python manage.py rundramatiq --queues default high_priority
+"""
 
-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",
-        )
+from django_cfg.modules.django_tasks.management.commands.rundramatiq import Command as DramatiqCommand
 
-    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
+class Command(DramatiqCommand):
+    """
+    Alias for rundramatiq command.
 
-    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
+    Simply inherits from DramatiqCommand without any changes.
+    """
+    pass