django-cfg 1.3.7__py3-none-any.whl → 1.3.11__py3-none-any.whl

django_cfg/core/integration/__init__.py

@@ -4,21 +4,41 @@ Django CFG Integration Package.
 Provides URL integration and startup information display.
 """
 
+import os
+
 from .url_integration import add_django_cfg_urls, get_django_cfg_urls_info
 from .display.startup import StartupDisplayManager
 from .display.ngrok import NgrokDisplayManager
 
+# Module-level flag that persists across hot reloads
+_startup_info_shown = False
+
+
 def print_startup_info():
     """Print startup information based on config.startup_info_mode."""
+    # Skip startup info in development mode to avoid hot reload spam
+    try:
+        from django.conf import settings
+        if settings.DEBUG:
+            return
+    except Exception:
+        pass
+    
     try:
         manager = StartupDisplayManager()
         manager.display_startup_info()
+            
     except Exception as e:
         import traceback
         print(f"❌ ERROR in print_startup_info: {e}")
         print("🔍 TRACEBACK:")
         traceback.print_exc()
 
+def reset_startup_info_flag():
+    """Reset the startup info display flag. Useful for testing or manual reset."""
+    global _startup_info_shown
+    _startup_info_shown = False
+
 def print_ngrok_tunnel_info(tunnel_url: str):
     """Print ngrok tunnel information after tunnel is established."""
     try:
@@ -37,6 +57,7 @@ __all__ = [
     "add_django_cfg_urls",
     "get_django_cfg_urls_info", 
     "print_startup_info",
+    "reset_startup_info_flag",
     "print_ngrok_tunnel_info",
     "get_version_info",
     "get_latest_version", 

django_cfg/management/commands/__init__.py

@@ -1 +1,13 @@
-# Django management commands
+"""
+Django management commands for django-cfg.
+
+This package contains all Django management commands including:
+
+Django App Agent Commands:
+- app_agent_generate: Generate Django applications with AI assistance
+- app_agent_diagnose: Diagnose problems in Django/Django-cfg projects  
+- app_agent_info: Show information about Django App Agent capabilities
+
+Other Commands:
+- Various utility and maintenance commands
+"""

django_cfg/management/commands/migrate_all.py

@@ -73,7 +73,9 @@ class Command(BaseCommand):
                             try:
                                 call_command("migrate", app_label, database=db_name, verbosity=1)
                             except Exception as e:
-                                self.stdout.write(self.style.WARNING(f"  ⚠️  Warning: {e}"))
+                                self.stdout.write(self.style.ERROR(f"  ❌ Migration failed for {app_label} on {db_name}: {e}"))
+                                logger.error(f"Migration failed for {app_label} on {db_name}: {e}")
+                                raise SystemExit(1)
                         else:
                             self.stdout.write(f"  Would run: migrate {app_label} --database={db_name}")
             else:
@@ -83,7 +85,9 @@ class Command(BaseCommand):
                     try:
                         call_command("migrate", database=db_name, verbosity=1)
                     except Exception as e:
-                        self.stdout.write(self.style.WARNING(f"  ⚠️  Warning: {e}"))
+                        self.stdout.write(self.style.ERROR(f"  ❌ Migration failed for all apps on {db_name}: {e}"))
+                        logger.error(f"Migration failed for all apps on {db_name}: {e}")
+                        raise SystemExit(1)
                 else:
                     self.stdout.write(f"  Would run: migrate --database={db_name}")
 
@@ -93,7 +97,9 @@ class Command(BaseCommand):
             try:
                 call_command("migrate", "constance", database="default", verbosity=1)
             except Exception as e:
-                self.stdout.write(self.style.WARNING(f"⚠️  Constance warning: {e}"))
+                self.stdout.write(self.style.ERROR(f"❌ Constance migration failed: {e}"))
+                logger.error(f"Constance migration failed: {e}")
+                raise SystemExit(1)
         else:
             self.stdout.write("  Would run: migrate constance --database=default")
 

django_cfg/management/commands/migrator.py

@@ -125,6 +125,11 @@ class Command(BaseCommand):
         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:
@@ -154,12 +159,12 @@ class Command(BaseCommand):
                     self.stdout.write(f"  📦 Migrating {app}...")
                     call_command("migrate", app, database=db_name, verbosity=1)
                 except Exception as e:
-                    self.stdout.write(self.style.WARNING(f"  ⚠️  Warning migrating {app}: {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.stdout.write(self.style.ERROR(f"❌ Error migrating {db_name}: {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"""
@@ -173,12 +178,12 @@ class Command(BaseCommand):
                     call_command("migrate", "constance", database="default", verbosity=1)
                     self.stdout.write(self.style.SUCCESS("✅ Constance migration completed!"))
                 except Exception as e:
-                    self.stdout.write(self.style.WARNING(f"⚠️  Constance migration warning: {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.stdout.write(self.style.WARNING(f"⚠️  Could not migrate constance: {e}"))
+            self._raise_system_exit(f"Could not migrate constance: {e}")
 
     def migrate_app(self, app_name):
         """Migrate specific app across all databases"""
@@ -192,7 +197,7 @@ class Command(BaseCommand):
                 try:
                     call_command("migrate", app_name, database=db_name, verbosity=1)
                 except Exception as e:
-                    self.stdout.write(self.style.WARNING(f"  ⚠️  Warning: {e}"))
+                    self._raise_system_exit(f"Migration failed for {app_name} on {db_name}: {e}")
 
     def show_database_status(self):
         """Show status of all databases and their apps"""
@@ -265,7 +270,7 @@ class Command(BaseCommand):
             self.stdout.write(f"📦 Installed Apps: {len(settings.INSTALLED_APPS)}")
 
         except Exception as e:
-            self.stdout.write(self.style.ERROR(f"❌ Error getting Django config info: {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"""

django_cfg/management/commands/rundramatiq.py

@@ -16,8 +16,6 @@ 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_logger import get_logger
-
-
 from django_cfg.modules.django_tasks import get_task_service
 
 
@@ -111,8 +109,10 @@ class Command(BaseCommand):
         # If dry run, show command and exit
         if dry_run:
             executable_name = "dramatiq"
+            
             process_args = [
                 executable_name,
+                "django_cfg.modules.dramatiq_setup",  # Broker module
                 "--processes", str(processes),
                 "--threads", str(threads),
                 "--worker-shutdown-timeout", str(worker_shutdown_timeout),
@@ -150,6 +150,7 @@ class Command(BaseCommand):
         # Build process arguments exactly like django_dramatiq
         process_args = [
             executable_name,
+            "django_cfg.modules.dramatiq_setup",  # Broker module
             "--processes", str(processes),
             "--threads", str(threads),
             "--worker-shutdown-timeout", str(worker_shutdown_timeout),

django_cfg/management/commands/rundramatiq_simulator.py

@@ -0,0 +1,430 @@
+"""
+Django management command for simulating Dramatiq tasks and workers.
+
+Usage:
+    python manage.py rundramatiq_simulator --help
+    python manage.py rundramatiq_simulator --workers 5
+    python manage.py rundramatiq_simulator --clear-only
+    python manage.py rundramatiq_simulator --show-keys
+"""
+
+import redis
+import json
+import time
+from datetime import datetime, timezone
+import random
+from typing import Dict, Any, Optional
+
+from django.core.management.base import BaseCommand, CommandError
+from django.conf import settings
+
+from django_cfg.modules.django_tasks import DjangoTasks
+
+
+class TaskSimulator:
+    """Task data simulator for Tasks Dashboard."""
+    
+    def __init__(self):
+        """Initialize the simulator."""
+        self.tasks_service = DjangoTasks()
+        
+        # Get Redis client using the same logic as DjangoTasks
+        try:
+            redis_url = self.tasks_service.get_redis_url()
+            if not redis_url:
+                raise RuntimeError("No Redis URL available")
+            
+            # Parse URL for connection
+            from urllib.parse import urlparse
+            parsed = urlparse(redis_url)
+            
+            self.redis_client = redis.Redis(
+                host=parsed.hostname or 'localhost',
+                port=parsed.port or 6379,
+                db=int(parsed.path.lstrip('/')) if parsed.path else 1,
+                decode_responses=True
+            )
+                
+        except Exception as e:
+            raise CommandError(f"Failed to connect to Redis: {e}")
+        
+        # Get queue configuration
+        try:
+            config = self.tasks_service.get_config()
+            self.queues = config.tasks.dramatiq.queues
+        except Exception as e:
+            # Use default queues if we can't get configuration
+            self.queues = ['critical', 'high', 'default', 'low', 'background', 'payments', 'agents']
+    
+    def clear_all_data(self) -> int:
+        """
+        Clear all test data.
+        
+        Returns:
+            Number of deleted keys
+        """
+        keys = self.redis_client.keys("dramatiq:*")
+        if keys:
+            deleted = self.redis_client.delete(*keys)
+            return deleted
+        return 0
+    
+    def simulate_queues(self, pending_tasks_per_queue=None, failed_tasks_per_queue=None) -> Dict[str, Dict[str, int]]:
+        """
+        Simulate queues with tasks.
+        
+        Args:
+            pending_tasks_per_queue: Dict[str, int] - number of pending tasks per queue
+            failed_tasks_per_queue: Dict[str, int] - number of failed tasks per queue
+            
+        Returns:
+            Dict with information about created tasks
+        """
+        if pending_tasks_per_queue is None:
+            pending_tasks_per_queue = {
+                'critical': 2,
+                'high': 5,
+                'default': 12,
+                'low': 8,
+                'background': 15,
+                'payments': 3,
+                'agents': 7
+            }
+        
+        if failed_tasks_per_queue is None:
+            failed_tasks_per_queue = {
+                'critical': 0,
+                'high': 1,
+                'default': 3,
+                'low': 2,
+                'background': 1,
+                'payments': 0,
+                'agents': 1
+            }
+        
+        results = {}
+        
+        for queue_name in self.queues:
+            queue_results = {'pending': 0, 'failed': 0}
+            
+            # Pending tasks
+            pending_count = pending_tasks_per_queue.get(queue_name, 0)
+            if pending_count > 0:
+                queue_key = f"dramatiq:default.DQ.{queue_name}"
+                
+                # Add fake tasks to queue
+                for i in range(pending_count):
+                    task_data = {
+                        "queue_name": queue_name,
+                        "actor_name": f"process_{queue_name}_task",
+                        "args": [f"task_{i}"],
+                        "kwargs": {},
+                        "options": {},
+                        "message_id": f"msg_{queue_name}_{i}_{int(time.time())}",
+                        "message_timestamp": int(time.time() * 1000)
+                    }
+                    self.redis_client.lpush(queue_key, json.dumps(task_data))
+                
+                queue_results['pending'] = pending_count
+            
+            # Failed tasks
+            failed_count = failed_tasks_per_queue.get(queue_name, 0)
+            if failed_count > 0:
+                failed_key = f"dramatiq:default.DQ.{queue_name}.failed"
+                
+                # Add fake failed tasks
+                for i in range(failed_count):
+                    failed_task_data = {
+                        "queue_name": queue_name,
+                        "actor_name": f"failed_{queue_name}_task",
+                        "args": [f"failed_task_{i}"],
+                        "kwargs": {},
+                        "options": {},
+                        "message_id": f"failed_msg_{queue_name}_{i}_{int(time.time())}",
+                        "message_timestamp": int(time.time() * 1000),
+                        "error": f"Simulated error for {queue_name} task {i}"
+                    }
+                    self.redis_client.lpush(failed_key, json.dumps(failed_task_data))
+                
+                queue_results['failed'] = failed_count
+            
+            if queue_results['pending'] > 0 or queue_results['failed'] > 0:
+                results[queue_name] = queue_results
+        
+        return results
+    
+    def simulate_workers(self, worker_count=3) -> list:
+        """
+        Симулировать активных воркеров.
+        
+        Args:
+            worker_count: Количество воркеров для симуляции
+            
+        Returns:
+            Список ID созданных воркеров
+        """
+        worker_ids = []
+        
+        for i in range(worker_count):
+            worker_id = f"worker_{i}_{int(time.time())}"
+            worker_key = f"dramatiq:worker:{worker_id}"
+            
+            worker_data = {
+                "worker_id": worker_id,
+                "hostname": f"localhost",
+                "pid": 1000 + i,
+                "queues": self.queues,
+                "started_at": datetime.now(timezone.utc).isoformat(),
+                "last_heartbeat": datetime.now(timezone.utc).isoformat(),
+                "status": "active"
+            }
+            
+            # Устанавливаем данные воркера с TTL
+            self.redis_client.setex(
+                worker_key, 
+                300,  # 5 минут TTL
+                json.dumps(worker_data)
+            )
+            
+            worker_ids.append(worker_id)
+        
+        return worker_ids
+    
+    def simulate_task_statistics(self) -> Dict[str, Any]:
+        """
+        Симулировать статистику задач.
+        
+        Returns:
+            Созданная статистика
+        """
+        stats_data = {
+            "total_processed": random.randint(1000, 2000),
+            "total_failed": random.randint(30, 80),
+            "total_retried": random.randint(15, 40),
+            "processing_time_avg": round(random.uniform(1.5, 4.0), 2),
+            "last_updated": datetime.now(timezone.utc).isoformat()
+        }
+        
+        stats_key = "dramatiq:stats"
+        self.redis_client.setex(stats_key, 3600, json.dumps(stats_data))
+        
+        return stats_data
+    
+    def run_simulation(self, workers=3, clear_first=True) -> Dict[str, Any]:
+        """
+        Запустить полную симуляцию.
+        
+        Args:
+            workers: Количество воркеров
+            clear_first: Очистить данные перед симуляцией
+            
+        Returns:
+            Результаты симуляции
+        """
+        results = {
+            'cleared_keys': 0,
+            'queues': {},
+            'workers': [],
+            'statistics': {}
+        }
+        
+        if clear_first:
+            results['cleared_keys'] = self.clear_all_data()
+        
+        results['queues'] = self.simulate_queues()
+        results['workers'] = self.simulate_workers(workers)
+        results['statistics'] = self.simulate_task_statistics()
+        
+        return results
+    
+    def get_redis_summary(self) -> Dict[str, Any]:
+        """Получить сводку по данным в Redis."""
+        summary = {
+            'total_keys': 0,
+            'queues': {},
+            'workers': 0,
+            'statistics': None
+        }
+        
+        # Подсчитываем все ключи
+        all_keys = self.redis_client.keys("dramatiq:*")
+        summary['total_keys'] = len(all_keys)
+        
+        # Анализируем очереди
+        for queue_name in self.queues:
+            pending_key = f"dramatiq:default.DQ.{queue_name}"
+            failed_key = f"dramatiq:default.DQ.{queue_name}.failed"
+            
+            pending = self.redis_client.llen(pending_key)
+            failed = self.redis_client.llen(failed_key)
+            
+            if pending > 0 or failed > 0:
+                summary['queues'][queue_name] = {
+                    'pending': pending,
+                    'failed': failed
+                }
+        
+        # Подсчитываем воркеров
+        worker_keys = self.redis_client.keys("dramatiq:worker:*")
+        summary['workers'] = len(worker_keys)
+        
+        # Получаем статистику
+        stats_key = "dramatiq:stats"
+        if self.redis_client.exists(stats_key):
+            try:
+                stats_data = self.redis_client.get(stats_key)
+                summary['statistics'] = json.loads(stats_data)
+            except:
+                pass
+        
+        return summary
+
+
+class Command(BaseCommand):
+    """Django management command для симуляции Dramatiq данных."""
+    
+    help = 'Simulate Dramatiq tasks and workers for dashboard testing'
+    
+    def add_arguments(self, parser):
+        """Добавить аргументы команды."""
+        parser.add_argument(
+            '--workers',
+            type=int,
+            default=3,
+            help='Number of workers to simulate (default: 3)'
+        )
+        
+        parser.add_argument(
+            '--no-clear',
+            action='store_true',
+            help='Do not clear existing data before simulation'
+        )
+        
+        parser.add_argument(
+            '--clear-only',
+            action='store_true',
+            help='Only clear data, do not simulate'
+        )
+        
+        parser.add_argument(
+            '--show-keys',
+            action='store_true',
+            help='Show Redis keys after operation'
+        )
+        
+        parser.add_argument(
+            '--summary',
+            action='store_true',
+            help='Show summary of current Redis data'
+        )
+    
+    def handle(self, *args, **options):
+        """Выполнить команду."""
+        try:
+            simulator = TaskSimulator()
+            
+            # Показать только сводку
+            if options['summary']:
+                self.show_summary(simulator)
+                return
+            
+            # Только очистка
+            if options['clear_only']:
+                self.stdout.write("🧹 Clearing all test data...")
+                cleared = simulator.clear_all_data()
+                self.stdout.write(
+                    self.style.SUCCESS(f"✅ Cleared {cleared} Redis keys")
+                )
+                return
+            
+            # Полная симуляция
+            self.stdout.write("🎭 Starting Dramatiq Task Simulation")
+            self.stdout.write("=" * 50)
+            
+            results = simulator.run_simulation(
+                workers=options['workers'],
+                clear_first=not options['no_clear']
+            )
+            
+            # Показываем результаты
+            if results['cleared_keys'] > 0:
+                self.stdout.write(f"🧹 Cleared {results['cleared_keys']} existing keys")
+            
+            self.stdout.write(f"📋 Created queues:")
+            total_pending = 0
+            total_failed = 0
+            
+            for queue_name, counts in results['queues'].items():
+                pending = counts['pending']
+                failed = counts['failed']
+                total_pending += pending
+                total_failed += failed
+                
+                self.stdout.write(f"   {queue_name}: {pending} pending, {failed} failed")
+            
+            self.stdout.write(f"👷 Created {len(results['workers'])} workers")
+            self.stdout.write(f"📊 Added task statistics")
+            
+            self.stdout.write("=" * 50)
+            self.stdout.write(self.style.SUCCESS("✅ Simulation completed!"))
+            
+            self.stdout.write(f"\n📊 Summary:")
+            active_queues = len(results['queues'])
+            self.stdout.write(f"   Active Queues: {active_queues}")
+            self.stdout.write(f"   Active Workers: {len(results['workers'])}")
+            self.stdout.write(f"   Pending Tasks: {total_pending}")
+            self.stdout.write(f"   Failed Tasks: {total_failed}")
+            
+            self.stdout.write(f"\n🌐 Dashboard URL: http://localhost:8000/cfg/admin/django_cfg_tasks/admin/dashboard/")
+            
+            # Показать ключи если запрошено
+            if options['show_keys']:
+                self.show_redis_keys(simulator)
+                
+        except Exception as e:
+            raise CommandError(f"Simulation failed: {e}")
+    
+    def show_summary(self, simulator: TaskSimulator):
+        """Показать сводку текущих данных."""
+        self.stdout.write("📊 Current Redis Data Summary")
+        self.stdout.write("=" * 40)
+        
+        summary = simulator.get_redis_summary()
+        
+        self.stdout.write(f"Total Redis keys: {summary['total_keys']}")
+        self.stdout.write(f"Active workers: {summary['workers']}")
+        
+        if summary['queues']:
+            self.stdout.write("\nQueues:")
+            for queue_name, counts in summary['queues'].items():
+                self.stdout.write(f"   {queue_name}: {counts['pending']} pending, {counts['failed']} failed")
+        else:
+            self.stdout.write("\nNo active queues found")
+        
+        if summary['statistics']:
+            stats = summary['statistics']
+            self.stdout.write(f"\nStatistics:")
+            self.stdout.write(f"   Total processed: {stats.get('total_processed', 'N/A')}")
+            self.stdout.write(f"   Total failed: {stats.get('total_failed', 'N/A')}")
+            self.stdout.write(f"   Avg processing time: {stats.get('processing_time_avg', 'N/A')}s")
+    
+    def show_redis_keys(self, simulator: TaskSimulator):
+        """Показать все Redis ключи."""
+        self.stdout.write("\n🔍 Redis Keys:")
+        keys = simulator.redis_client.keys("dramatiq:*")
+        
+        if not keys:
+            self.stdout.write("   No Dramatiq keys found")
+            return
+        
+        for key in sorted(keys):
+            key_type = simulator.redis_client.type(key)
+            if key_type == 'list':
+                length = simulator.redis_client.llen(key)
+                self.stdout.write(f"   {key} (list): {length} items")
+            elif key_type == 'string':
+                ttl = simulator.redis_client.ttl(key)
+                ttl_str = f"TTL {ttl}s" if ttl > 0 else "no TTL"
+                self.stdout.write(f"   {key} (string): {ttl_str}")
+            else:
+                self.stdout.write(f"   {key} ({key_type})")

django_cfg/middleware/__init__.py

@@ -5,9 +5,7 @@ Provides middleware components for Django CFG applications.
 """
 
 from .user_activity import UserActivityMiddleware
-from .static_nocache import StaticNoCacheMiddleware
 
 __all__ = [
     'UserActivityMiddleware',
-    'StaticNoCacheMiddleware',
 ]