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

django_cfg/core/integration/display/startup.py

@@ -2,22 +2,22 @@
 Startup display manager for Django CFG.
 """
 
-from typing import Optional, Dict, Any, List
-from rich.text import Text
-from rich.table import Table
 from rich.panel import Panel
-from .base import BaseDisplayManager, MAIN_PANEL_WIDTH, HALF_PANEL_WIDTH
+from rich.table import Table
+from rich.text import Text
+
+from .base import BaseDisplayManager
 from .ngrok import NgrokDisplayManager
 
 
 class StartupDisplayManager(BaseDisplayManager):
     """Manager for displaying startup information."""
-    
+
     def __init__(self, config=None):
         """Initialize startup display manager."""
         super().__init__(config)
         self.ngrok_manager = NgrokDisplayManager(config)
-    
+
     def display_startup_info(self):
         """Display startup information based on config.startup_info_mode."""
         if not self.config:
@@ -35,7 +35,7 @@ class StartupDisplayManager(BaseDisplayManager):
             self.display_essential_info()
         elif mode == StartupInfoMode.FULL:
             self.display_complete_info()
-    
+
     def display_minimal_info(self):
         """Display minimal startup info (NONE mode)."""
         try:
@@ -70,7 +70,7 @@ class StartupDisplayManager(BaseDisplayManager):
             print(f"❌ ERROR in display_minimal_info: {e}")
             print("🔍 TRACEBACK:")
             traceback.print_exc()
-    
+
     def display_essential_info(self):
         """Display essential startup info (SHORT mode)."""
         try:
@@ -105,7 +105,7 @@ class StartupDisplayManager(BaseDisplayManager):
             print(f"❌ ERROR in display_essential_info: {e}")
             print("🔍 TRACEBACK:")
             traceback.print_exc()
-    
+
     def display_complete_info(self):
         """Display complete startup info (FULL mode)."""
         try:
@@ -114,8 +114,10 @@ class StartupDisplayManager(BaseDisplayManager):
 
             # Get library info
             from django_cfg.config import (
-                LIB_NAME, LIB_SITE_URL, LIB_DOCS_URL, LIB_GITHUB_URL,
-                LIB_SUPPORT_URL, LIB_HEALTH_URL
+                LIB_DOCS_URL,
+                LIB_GITHUB_URL,
+                LIB_SITE_URL,
+                LIB_SUPPORT_URL,
             )
 
             # Create main info table
@@ -172,17 +174,17 @@ class StartupDisplayManager(BaseDisplayManager):
             print(f"❌ ERROR in display_complete_info: {e}")
             print("🔍 TRACEBACK:")
             traceback.print_exc()
-    
+
     def _display_update_notification_short(self):
         """Display update notification for SHORT mode."""
         try:
             from ..version_checker import get_version_info
             version_info = get_version_info()
-            
+
             if version_info.get('update_available'):
                 current = version_info.get('current_version', 'unknown')
                 latest = version_info.get('latest_version', 'unknown')
-                
+
                 update_text = Text()
                 update_text.append("🚨 Update available: ", style="bold yellow")
                 update_text.append(f"{current}", style="red")
@@ -190,7 +192,7 @@ class StartupDisplayManager(BaseDisplayManager):
                 update_text.append(f"{latest}", style="green")
                 update_text.append("\n💡 Run: ", style="dim")
                 update_text.append("poetry add django-cfg@latest", style="bright_blue")
-                
+
                 update_panel = self.create_panel(
                     update_text,
                     title="",
@@ -201,38 +203,38 @@ class StartupDisplayManager(BaseDisplayManager):
                 self.console.print(update_panel)
         except Exception:
             pass
-    
+
     def _display_update_notification_full(self):
         """Display update notification for FULL mode."""
         try:
             from ..version_checker import get_version_info
             version_info = get_version_info()
-            
+
             if version_info.get('update_available'):
                 update_table = self.create_table()
                 update_table.add_column("Info", style="yellow", width=15)
                 update_table.add_column("Value", style="white")
-                
+
                 current = version_info.get('current_version', 'unknown')
                 latest = version_info.get('latest_version', 'unknown')
                 update_url = version_info.get('update_url', '')
-                
+
                 update_table.add_row("Current", f"[red]{current}[/red]")
                 update_table.add_row("Latest", f"[green]{latest}[/green]")
                 update_table.add_row("💡 Update", "[bright_blue]poetry add django-cfg@latest[/bright_blue]")
                 if update_url:
                     update_table.add_row("PyPI", update_url)
-                
+
                 update_panel = self.create_full_width_panel(
                     update_table,
                     title="🚨 Update Available",
                     border_style="yellow"
                 )
-                
+
                 self.console.print(update_panel)
         except Exception:
             pass
-    
+
     def _display_essential_columns(self):
         """Display essential info in columns for SHORT mode."""
         # Enabled apps
@@ -243,14 +245,14 @@ class StartupDisplayManager(BaseDisplayManager):
         for app in enabled_apps[:5]:  # Limit for SHORT mode
             app_name = app.split('.')[-1]
             apps_table.add_row(f"• {app_name}")
-        
+
         # Key endpoints
         endpoints_table = self.create_table()
         endpoints_table.add_column("Endpoint", style="bright_green")
-        
+
         endpoints_table.add_row(f"• {self.get_base_url('cfg', 'health')}")
         endpoints_table.add_row(f"• {self.get_base_url('api', 'payments')}")
-        
+
         # Use new two-column table method for perfect 50/50 layout
         self.print_two_column_table(
             left_content=apps_table,
@@ -260,7 +262,7 @@ class StartupDisplayManager(BaseDisplayManager):
             left_style="blue",
             right_style="green"
         )
-    
+
     def _display_main_columns(self):
         """Display main columns (apps and endpoints) for FULL mode."""
         # Enabled apps
@@ -271,15 +273,15 @@ class StartupDisplayManager(BaseDisplayManager):
         for app in enabled_apps:
             app_name = app.split('.')[-1]
             apps_table.add_row(f"• {app_name}")
-        
+
         # Endpoints
         endpoints_table = self.create_table()
         endpoints_table.add_column("Endpoint", style="bright_green")
-        
+
         # Add core endpoints
         endpoints_table.add_row(f"• {self.get_base_url('cfg', 'health')}")
         endpoints_table.add_row(f"• {self.get_base_url('cfg', 'commands')}")
-        
+
         # Add app-specific API endpoints based on enabled apps
         for app in enabled_apps:
             app_name = app.split('.')[-1]
@@ -287,7 +289,7 @@ class StartupDisplayManager(BaseDisplayManager):
                 continue
             else:
                 endpoints_table.add_row(f"• {self.get_base_url('api', app_name)}")
-        
+
         # Use new two-column table method for perfect 50/50 layout
         self.print_two_column_table(
             left_content=apps_table,
@@ -297,38 +299,38 @@ class StartupDisplayManager(BaseDisplayManager):
             left_style="blue",
             right_style="green"
         )
-    
+
     def _display_config_panels(self):
         """Display app-specific configuration panels."""
         config_panels = []
-        
+
         # Payments configuration
-        if (self.config and hasattr(self.config, 'payments') and 
+        if (self.config and hasattr(self.config, 'payments') and
             self.config.payments and self.config.payments.enabled):
-            
+
             payment_table = self.create_table()
             payment_table.add_column("Setting", style="cyan", width=20)
             payment_table.add_column("Value", style="white")
-            
+
             payment_table.add_row("Enabled", f"[green]{self.config.payments.enabled}[/green]")
             middleware_enabled = self.config.payments.middleware_enabled
             color = 'green' if middleware_enabled else 'red'
             payment_table.add_row("Middleware", f"[{color}]{middleware_enabled}[/{color}]")
-            
+
             config_panels.append(self.create_panel(
-                payment_table, 
-                title="💳 Payments", 
+                payment_table,
+                title="💳 Payments",
                 border_style="yellow"
             ))
-        
+
         # Tasks configuration - removed from config_panels, will be shown separately
-        
+
         # Constance configuration
         try:
             constance_table = self.create_table()
             constance_table.add_column("Setting", style="cyan", width=20)
             constance_table.add_column("Value", style="white")
-            
+
             # Constance fields moved to separate block
             # Get cache info
             try:
@@ -339,7 +341,7 @@ class StartupDisplayManager(BaseDisplayManager):
                     constance_table.add_row("Cache", "[yellow]Not configured[/yellow]")
             except Exception:
                 constance_table.add_row("Cache", "[red]Error[/red]")
-            
+
             # Add validation info
             try:
                 from django_cfg.core.validation import ConfigurationValidator
@@ -351,22 +353,22 @@ class StartupDisplayManager(BaseDisplayManager):
                     constance_table.add_row("Validation", f"[red]✗ {error_count} errors[/red]")
             except Exception:
                 constance_table.add_row("Validation", "[red]Error[/red]")
-            
+
             # Add installed apps count
             try:
                 installed_apps = self.config.get_installed_apps() if hasattr(self.config, 'get_installed_apps') else []
                 constance_table.add_row("Apps", f"[blue]{len(installed_apps)}[/blue]")
             except Exception:
                 constance_table.add_row("Apps", "[red]Error[/red]")
-            
+
             config_panels.append(self.create_panel(
-                constance_table, 
-                title="⚙️ Configuration", 
+                constance_table,
+                title="⚙️ Configuration",
                 border_style="cyan"
             ))
         except Exception:
             pass
-        
+
         # Show config panels
         if len(config_panels) >= 2:
             # Show first two panels in 50/50 layout
@@ -378,7 +380,7 @@ class StartupDisplayManager(BaseDisplayManager):
                 left_style=config_panels[0].border_style,
                 right_style=config_panels[1].border_style
             )
-            
+
             # Show remaining panels individually
             for panel in config_panels[2:]:
                 self.console.print(panel)
@@ -386,73 +388,73 @@ class StartupDisplayManager(BaseDisplayManager):
             # Show single panel
             for panel in config_panels:
                 self.console.print(panel)
-        
+
         # Show Background Tasks separately
         self._display_background_tasks()
-        
+
         # Show detailed Constance information (includes summary)
         self._display_constance_details()
-    
+
     def _display_background_tasks(self):
         """Display Background Tasks information in a separate panel."""
         try:
             # Always show Background Tasks section if config exists
             if not self.config:
                 return
-                
+
             task_table = self.create_table()
             task_table.add_column("Setting", style="cyan", width=20)
             task_table.add_column("Value", style="white")
-            
+
             # Show real tasks status
             tasks_enabled = self.config.should_enable_tasks()
             if tasks_enabled:
                 task_table.add_row("Tasks Enabled", "[green]True[/green]")
             else:
                 task_table.add_row("Tasks Enabled", "[yellow]False[/yellow]")
-            
+
             if hasattr(self.config, 'tasks') and self.config.tasks:
                 queue_name = getattr(self.config.tasks, 'queue_name', 'default')
                 task_table.add_row("Queue", f"[yellow]{queue_name}[/yellow]")
             else:
                 task_table.add_row("Queue", "[yellow]default[/yellow]")
-            
+
             # Add worker command
             task_table.add_row("Start Workers", "[bright_blue]poetry run python manage.py rundramatiq[/bright_blue]")
-            
+
             task_panel = self.create_full_width_panel(
-                task_table, 
-                title="⚡ Background Tasks", 
+                task_table,
+                title="⚡ Background Tasks",
                 border_style="purple"
             )
-            
+
             self.console.print(task_panel)
-            
+
         except Exception as e:
             import traceback
             print(f"❌ ERROR in _display_background_tasks: {e}")
             traceback.print_exc()
-    
+
     def _display_constance_integrated_block(self, constance_config, all_fields):
         """Display integrated Constance block with summary and field details."""
         try:
             # Create main content table that will contain everything
             main_content = Table(show_header=False, box=None, padding=(0, 1))
             main_content.add_column("Content", justify="left")
-            
+
             # 1. Add summary section
             summary_table = self.create_table()
             summary_table.add_column("Source", style="cyan", width=20)
             summary_table.add_column("Fields", style="white")
-            
+
             # Count fields by source
             user_fields = len(constance_config.fields)
-            
+
             # Count by app
             tasks_count = 0
             knowbase_count = 0
             payments_count = 0
-            
+
             config = self.config
             if config and config.should_enable_tasks():
                 try:
@@ -461,23 +463,27 @@ class StartupDisplayManager(BaseDisplayManager):
                     tasks_count = len(tasks_fields)
                 except:
                     pass
-            
+
             if config and config.enable_knowbase:
                 try:
-                    from django_cfg.apps.knowbase.config import get_django_cfg_knowbase_constance_fields
+                    from django_cfg.apps.knowbase.config import (
+                        get_django_cfg_knowbase_constance_fields,
+                    )
                     knowbase_fields = get_django_cfg_knowbase_constance_fields()
                     knowbase_count = len(knowbase_fields)
                 except:
                     pass
-            
+
             if config and config.payments and config.payments.enabled:
                 try:
-                    from django_cfg.apps.payments.config import get_django_cfg_payments_constance_fields
+                    from django_cfg.apps.payments.config import (
+                        get_django_cfg_payments_constance_fields,
+                    )
                     payments_fields = get_django_cfg_payments_constance_fields()
                     payments_count = len(payments_fields)
                 except:
                     pass
-            
+
             summary_table.add_row("User Defined", f"[blue]{user_fields}[/blue]")
             if tasks_count > 0:
                 summary_table.add_row("Tasks Module", f"[green]{tasks_count}[/green]")
@@ -486,10 +492,10 @@ class StartupDisplayManager(BaseDisplayManager):
             if payments_count > 0:
                 summary_table.add_row("Payments App", f"[green]{payments_count}[/green]")
             summary_table.add_row("Total", f"[yellow]{len(all_fields)}[/yellow]")
-            
+
             main_content.add_row(summary_table)
             main_content.add_row("")  # Spacer
-            
+
             # 2. Add field details section
             groups = {}
             for field in all_fields:
@@ -497,29 +503,29 @@ class StartupDisplayManager(BaseDisplayManager):
                 if group not in groups:
                     groups[group] = []
                 groups[group].append(field)
-            
+
             group_names = list(groups.keys())[:2]
-            
+
             if len(group_names) >= 2:
                 # Create two-column layout for field details
                 details_table = Table(show_header=False, box=None, padding=(0, 2))
                 details_table.add_column("Left", justify="left")
                 details_table.add_column("Right", justify="left")
-                
+
                 # Left column - first group
                 left_table = self.create_table()
                 left_table.add_column("Field", style="bright_cyan")
                 left_table.add_column("Type", style="yellow")
                 for field in groups[group_names[0]][:8]:
                     left_table.add_row(field.name, field.field_type)
-                
-                # Right column - second group  
+
+                # Right column - second group
                 right_table = self.create_table()
                 right_table.add_column("Field", style="bright_cyan")
                 right_table.add_column("Type", style="yellow")
                 for field in groups[group_names[1]][:8]:
                     right_table.add_row(field.name, field.field_type)
-                
+
                 # Create panels for each group
                 left_panel = Panel(
                     left_table,
@@ -528,7 +534,7 @@ class StartupDisplayManager(BaseDisplayManager):
                     expand=True,
                     padding=(1, 1)
                 )
-                
+
                 right_panel = Panel(
                     right_table,
                     title=f"🔧 {group_names[1]} Settings",
@@ -536,21 +542,21 @@ class StartupDisplayManager(BaseDisplayManager):
                     expand=True,
                     padding=(1, 1)
                 )
-                
+
                 details_table.add_row(left_panel, right_panel)
                 main_content.add_row(details_table)
-            
+
             elif len(group_names) == 1:
                 # Single group
                 single_table = self.create_table()
                 single_table.add_column("Field", style="bright_cyan")
                 single_table.add_column("Type", style="yellow")
                 single_table.add_column("Default", style="white")
-                
+
                 for field in groups[group_names[0]][:10]:
                     default_str = str(field.default)[:20] + "..." if len(str(field.default)) > 20 else str(field.default)
                     single_table.add_row(field.name, field.field_type, default_str)
-                
+
                 single_panel = Panel(
                     single_table,
                     title=f"🔧 {group_names[0]} Settings",
@@ -559,53 +565,53 @@ class StartupDisplayManager(BaseDisplayManager):
                     padding=(1, 1)
                 )
                 main_content.add_row(single_panel)
-            
+
             # Create the main panel containing everything
             integrated_panel = self.create_full_width_panel(
                 main_content,
                 title="📊 Constance Fields Summary",
                 border_style="purple"
             )
-            
+
             self.console.print(integrated_panel)
-            
+
         except Exception as e:
             import traceback
             print(f"❌ ERROR in _display_constance_integrated_block: {e}")
             traceback.print_exc()
-    
+
     def _display_constance_details(self):
         """Display detailed Constance configuration information."""
         try:
             if not (self.config and hasattr(self.config, 'constance')):
                 return
-            
+
             constance_config = self.config.constance
             all_fields = constance_config.get_all_fields()
-            
+
             if not all_fields:
                 return
-            
+
             # Show integrated summary and details in one block
             self._display_constance_integrated_block(constance_config, all_fields)
-                
+
         except Exception as e:
             import traceback
             print(f"❌ ERROR in _display_constance_details: {e}")
             traceback.print_exc()
-    
+
     def _display_constance_summary(self, constance_config, all_fields):
         """Display summary of Constance fields by source."""
         try:
             # Count fields by source
             user_fields = len(constance_config.fields)  # User-defined fields
             app_fields = constance_config._get_app_constance_fields()
-            
+
             # Count by app
             tasks_count = 0
             knowbase_count = 0
             payments_count = 0
-            
+
             # Try to get individual app field counts
             config = self.config
             if config and config.should_enable_tasks():
@@ -615,52 +621,56 @@ class StartupDisplayManager(BaseDisplayManager):
                     tasks_count = len(tasks_fields)
                 except:
                     pass
-            
+
             if config and config.enable_knowbase:
                 try:
-                    from django_cfg.apps.knowbase.config import get_django_cfg_knowbase_constance_fields
+                    from django_cfg.apps.knowbase.config import (
+                        get_django_cfg_knowbase_constance_fields,
+                    )
                     knowbase_fields = get_django_cfg_knowbase_constance_fields()
                     knowbase_count = len(knowbase_fields)
                 except:
                     pass
-            
+
             if config and config.payments and config.payments.enabled:
                 try:
-                    from django_cfg.apps.payments.config import get_django_cfg_payments_constance_fields
+                    from django_cfg.apps.payments.config import (
+                        get_django_cfg_payments_constance_fields,
+                    )
                     payments_fields = get_django_cfg_payments_constance_fields()
                     payments_count = len(payments_fields)
                 except:
                     pass
-            
+
             # Create summary table
             summary_table = self.create_table()
             summary_table.add_column("Source", style="cyan", width=20)
             summary_table.add_column("Fields", style="white")
-            
+
             summary_table.add_row("User Defined", f"[blue]{user_fields}[/blue]")
-            
+
             if tasks_count > 0:
                 summary_table.add_row("Tasks Module", f"[green]{tasks_count}[/green]")
             if knowbase_count > 0:
                 summary_table.add_row("Knowbase App", f"[green]{knowbase_count}[/green]")
             if payments_count > 0:
                 summary_table.add_row("Payments App", f"[green]{payments_count}[/green]")
-            
+
             summary_table.add_row("Total", f"[yellow]{len(all_fields)}[/yellow]")
-            
+
             summary_panel = self.create_panel(
                 summary_table,
                 title="📊 Constance Fields Summary",
                 border_style="purple"
             )
-            
+
             self.console.print(summary_panel)
-            
+
         except Exception as e:
             import traceback
             print(f"❌ ERROR in _display_constance_summary: {e}")
             traceback.print_exc()
-    
+
     def _display_openapi_client_info(self):
         """Display Django Client (OpenAPI) information."""
         try:
@@ -696,91 +706,91 @@ class StartupDisplayManager(BaseDisplayManager):
             pass
         except Exception:
             pass
-    
+
     def _display_commands_info(self):
         """Display management commands information."""
         try:
-            from ..commands_collector import get_all_commands, get_commands_with_descriptions
-            
+            from ..commands_collector import get_all_commands
+
             # Get command counts
             all_commands = get_all_commands()
             core_count = sum(len(commands) for commands in all_commands.get('django_cfg_core', {}).values())
             app_count = sum(len(commands) for commands in all_commands.get('django_cfg_apps', {}).values())
             project_count = sum(len(commands) for commands in all_commands.get('project_commands', {}).values())
             total_count = core_count + app_count + project_count
-            
+
             # Main commands info
             commands_table = self.create_table()
             commands_table.add_column("Type", style="cyan", width=20)
             commands_table.add_column("Count", style="white")
-            
+
             commands_table.add_row("🔧 Core Commands", str(core_count))
             commands_table.add_row("📱 App Commands", str(app_count))
             commands_table.add_row("🏗️ Project Commands", str(project_count))
             commands_table.add_row("📊 Total", str(total_count))
-            
+
             commands_panel = self.create_full_width_panel(
                 commands_table,
                 title="⚡ Management Commands",
                 border_style="purple"
             )
-            
+
             self.console.print(commands_panel)
-            
+
             # Detailed commands breakdown
             self._display_commands_breakdown()
-            
+
         except Exception as e:
             import traceback
             print(f"❌ ERROR in _display_commands_info: {e}")
             traceback.print_exc()
-    
+
     def _display_commands_breakdown(self):
         """Display detailed commands breakdown."""
         try:
             from ..commands_collector import get_all_commands
             all_commands = get_all_commands()
-            
+
             columns_content = []
-            
+
             # Core commands
             core_commands_dict = all_commands.get('django_cfg_core', {})
             if core_commands_dict:
                 core_table = self.create_table()
                 core_table.add_column("Command", style="bright_blue")
-                
+
                 # Flatten all core commands
                 all_core_commands = []
                 for commands_list in core_commands_dict.values():
                     all_core_commands.extend(commands_list)
-                
+
                 for cmd in all_core_commands[:15]:  # Limit to first 15
                     core_table.add_row(f"• {cmd}")
-                
+
                 columns_content.append(self.create_panel(
-                    core_table, 
-                    title="🔧 Core Commands", 
+                    core_table,
+                    title="🔧 Core Commands",
                     border_style="blue"
                 ))
-            
+
             # App commands
             app_commands_dict = all_commands.get('django_cfg_apps', {})
             if app_commands_dict:
                 app_table = self.create_table()
                 app_table.add_column("Command", style="bright_green")
-                
+
                 for app_name, commands_list in app_commands_dict.items():
                     if commands_list:
                         app_table.add_row(f"[bold]{app_name.title()}:[/bold]")
                         for cmd in commands_list[:3]:  # Limit per app
                             app_table.add_row(f"  • {cmd}")
-                
+
                 columns_content.append(self.create_panel(
-                    app_table, 
-                    title="📱 App Commands", 
+                    app_table,
+                    title="📱 App Commands",
                     border_style="green"
                 ))
-            
+
             # Show command columns in 50/50 layout
             if len(columns_content) == 2:
                 self.print_two_column_table(
@@ -797,7 +807,7 @@ class StartupDisplayManager(BaseDisplayManager):
             elif columns_content:
                 # Fallback for other cases
                 self.print_columns(columns_content, equal=True, expand=True)
-            
+
             # Project commands (separate panel due to length)
             project_commands_dict = all_commands.get('project_commands', {})
             if project_commands_dict:
@@ -805,31 +815,31 @@ class StartupDisplayManager(BaseDisplayManager):
                 all_project_commands = []
                 for commands_list in project_commands_dict.values():
                     all_project_commands.extend(commands_list)
-                
+
                 # Split commands into two columns
                 mid_point = len(all_project_commands) // 2
                 left_commands = all_project_commands[:mid_point]
                 right_commands = all_project_commands[mid_point:]
-                
+
                 # Create two-column table inside one panel
                 project_columns_table = Table(show_header=False, box=None, padding=(0, 2))
                 project_columns_table.add_column("Left", justify="left")
                 project_columns_table.add_column("Right", justify="left")
-                
+
                 # Create content for each column
                 left_content = "\n".join([f"• {cmd}" for cmd in left_commands[:15]])  # Limit to 15 per column
                 right_content = "\n".join([f"• {cmd}" for cmd in right_commands[:15]])
-                
+
                 project_columns_table.add_row(left_content, right_content)
-                
+
                 project_panel = self.create_full_width_panel(
-                    project_columns_table, 
-                    title="🏗️ Project Commands", 
+                    project_columns_table,
+                    title="🏗️ Project Commands",
                     border_style="yellow"
                 )
-                
+
                 self.console.print(project_panel)
-                
+
         except Exception as e:
             import traceback
             print(f"❌ ERROR in _display_commands_breakdown: {e}")