django-cfg 1.4.46__py3-none-any.whl → 1.5.181__py3-none-any.whl

django_cfg/core/integration/display/startup.py

@@ -2,12 +2,15 @@
 Startup display manager for Django CFG.
 """
 
+from cmath import e
 from rich.panel import Panel
 from rich.table import Table
 from rich.text import Text
+import traceback
 
 from .base import BaseDisplayManager
 from .ngrok import NgrokDisplayManager
+from .ai_hints import AIHintsDisplayManager
 
 
 class StartupDisplayManager(BaseDisplayManager):
@@ -17,6 +20,7 @@ class StartupDisplayManager(BaseDisplayManager):
         """Initialize startup display manager."""
         super().__init__(config)
         self.ngrok_manager = NgrokDisplayManager(config)
+        self.ai_hints_manager = AIHintsDisplayManager(config)
 
     def display_startup_info(self):
         """Display startup information based on config.startup_info_mode."""
@@ -39,52 +43,48 @@ class StartupDisplayManager(BaseDisplayManager):
     def display_minimal_info(self):
         """Display minimal startup info (NONE mode)."""
         try:
-            version = self.get_version()
             panel_style, env_emoji, env_color = self.get_environment_style()
 
-            # Simple one-liner
-            info_text = Text()
-            info_text.append(f"{env_emoji} Django CFG ", style="bold")
-            info_text.append(f"v{version}", style="cyan")
-            info_text.append(" • ", style="dim")
-            info_text.append(f"{self.config.env_mode}", style=env_color)
-            info_text.append(" • ", style="dim")
-            info_text.append(f"{self.config.project_name}", style="white")
+            # Display beautiful ASCII art banner
+            self.print_banner(style="default", color=env_color)
+            self.print_spacing()
 
-            # Check for critical updates
-            try:
-                from ..version_checker import get_version_info
-                version_info = get_version_info()
-                if version_info.get('update_available'):
-                    info_text.append(" • ", style="dim")
-                    info_text.append("🚨 UPDATE AVAILABLE", style="bold yellow")
-                    info_text.append(" (", style="dim")
-                    info_text.append("poetry add django-cfg@latest", style="bright_blue")
-                    info_text.append(")", style="dim")
-            except Exception:
-                pass
+            # Use reusable header utility
+            info_text = self.create_header_text(show_update_check=True)
+
+            # Add startup time if available
+            startup_time = self._get_startup_time()
+            if startup_time:
+                info_text.append(" • ", style="dim")
+                info_text.append(f"⚡ {startup_time}", style="green")
 
             self.console.print(info_text)
+
+            # Show logging info
+            self._display_logging_info()
         except Exception as e:
-            import traceback
             print(f"❌ ERROR in display_minimal_info: {e}")
             print("🔍 TRACEBACK:")
             traceback.print_exc()
+            exit(1)
 
     def display_essential_info(self):
         """Display essential startup info (SHORT mode)."""
         try:
-            version = self.get_version()
             panel_style, env_emoji, env_color = self.get_environment_style()
 
-            # Create compact header
-            header_text = Text()
-            header_text.append(f"{env_emoji} Django CFG ", style="bold")
-            header_text.append(f"v{version}", style="cyan")
-            header_text.append(" • ", style="dim")
-            header_text.append(f"{self.config.env_mode}", style=env_color)
-            header_text.append(" • ", style="dim")
-            header_text.append(f"{self.config.project_name}", style="white")
+            # Display beautiful ASCII art banner
+            self.print_banner(style="default", color=env_color)
+            self.print_spacing()
+
+            # Create compact header using reusable utility
+            header_text = self.create_header_text(show_update_check=False)
+
+            # Add startup time if available
+            startup_time = self._get_startup_time()
+            if startup_time:
+                header_text.append(" • ", style="dim")
+                header_text.append(f"⚡ {startup_time}", style="green")
 
             header_panel = self.create_panel(
                 header_text,
@@ -100,11 +100,17 @@ class StartupDisplayManager(BaseDisplayManager):
 
             # Create columns for essential info
             self._display_essential_columns()
+
+            # Show logging info
+            self._display_logging_info()
+
+            # Display AI hints (short mode)
+            self._display_ai_hints(mode="short")
         except Exception as e:
-            import traceback
             print(f"❌ ERROR in display_essential_info: {e}")
             print("🔍 TRACEBACK:")
             traceback.print_exc()
+            exit(1)
 
     def display_complete_info(self):
         """Display complete startup info (FULL mode)."""
@@ -112,14 +118,23 @@ class StartupDisplayManager(BaseDisplayManager):
             version = self.get_version()
             panel_style, env_emoji, env_color = self.get_environment_style()
 
+            # Display beautiful ASCII art banner
+            self.print_banner(style="default", color=env_color)
+            self.print_spacing()
+
             # Get library info
             from django_cfg.config import (
-                LIB_DOCS_URL,
+                LIB_SITE_URL,
                 LIB_GITHUB_URL,
                 LIB_SITE_URL,
                 LIB_SUPPORT_URL,
             )
 
+            # Display header using reusable utility
+            header_text = self.create_header_text(show_update_check=False)
+            self.console.print(header_text)
+            self.print_spacing()
+
             # Create main info table
             info_table = self.create_table()
             info_table.add_column("Setting", style="cyan", width=30)
@@ -129,14 +144,24 @@ class StartupDisplayManager(BaseDisplayManager):
             info_table.add_row("🔗 Prefix", "/cfg/")
             info_table.add_row("🌍 Environment", self.config.env_mode)
             info_table.add_row("🔧 Debug", str(self.config.debug))
+
+            # Show debug_warnings status
+            if self.config.debug_warnings:
+                info_table.add_row("🔍 Warnings Debug", "[yellow]Enabled (full traceback)[/yellow]")
+
             info_table.add_row("🏗️ Project", self.config.project_name)
 
+            # Add startup time if available
+            startup_time = self._get_startup_time()
+            if startup_time:
+                info_table.add_row("⚡ Startup Time", f"[green]{startup_time}[/green]")
+
             # Add environment source
             env_source = getattr(self.config, 'env_mode', 'default_fallback')
             info_table.add_row("🔍 Env Source", env_source)
 
             info_table.add_row("🌐 Site", LIB_SITE_URL)
-            info_table.add_row("📚 Docs", LIB_DOCS_URL)
+            info_table.add_row("📚 Docs", LIB_SITE_URL)
             info_table.add_row("🐙 GitHub", LIB_GITHUB_URL)
             info_table.add_row("🆘 Support", LIB_SUPPORT_URL)
 
@@ -168,12 +193,18 @@ class StartupDisplayManager(BaseDisplayManager):
             # Management commands
             self._display_commands_info()
 
+            # Show logging info
+            self._display_logging_info()
+
+            # Display AI hints (full mode)
+            self._display_ai_hints(mode="full")
+
             self.print_spacing()
         except Exception as e:
-            import traceback
             print(f"❌ ERROR in display_complete_info: {e}")
             print("🔍 TRACEBACK:")
             traceback.print_exc()
+            exit(1)
 
     def _display_update_notification_short(self):
         """Display update notification for SHORT mode."""
@@ -201,8 +232,11 @@ class StartupDisplayManager(BaseDisplayManager):
                 )
                 update_panel.padding = (0, 2)  # Override padding
                 self.console.print(update_panel)
-        except Exception:
-            pass
+        except Exception as e:
+            print(f"❌ ERROR in _display_update_notification_short: {e}")
+            print("🔍 TRACEBACK:")
+            traceback.print_exc()
+            exit(1)
 
     def _display_update_notification_full(self):
         """Display update notification for FULL mode."""
@@ -411,20 +445,20 @@ class StartupDisplayManager(BaseDisplayManager):
             task_table.add_column("Value", style="white")
 
             # Show real tasks status
-            tasks_enabled = self.config.should_enable_tasks()
+            tasks_enabled = self.config.should_enable_rq()
             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]")
+            if hasattr(self.config, 'django_rq') and self.config.django_rq:
+                queue_names = ', '.join(self.config.django_rq.get_queue_names())
+                task_table.add_row("Queues", f"[yellow]{queue_names}[/yellow]")
             else:
-                task_table.add_row("Queue", "[yellow]default[/yellow]")
+                task_table.add_row("Queues", "[yellow]default[/yellow]")
 
             # Add worker command
-            task_table.add_row("Start Workers", "[bright_blue]poetry run python manage.py rundramatiq[/bright_blue]")
+            task_table.add_row("Start Workers", "[bright_blue]poetry run python manage.py rqworker default[/bright_blue]")
 
             task_panel = self.create_full_width_panel(
                 task_table,
@@ -435,9 +469,9 @@ class StartupDisplayManager(BaseDisplayManager):
             self.console.print(task_panel)
 
         except Exception as e:
-            import traceback
             print(f"❌ ERROR in _display_background_tasks: {e}")
             traceback.print_exc()
+            exit(1)
 
     def _display_constance_integrated_block(self, constance_config, all_fields):
         """Display integrated Constance block with summary and field details."""
@@ -454,39 +488,36 @@ class StartupDisplayManager(BaseDisplayManager):
             # Count fields by source
             user_fields = len(constance_config.fields)
 
-            # Count by app
+            # Count by app (extensions are now auto-discovered)
             tasks_count = 0
             knowbase_count = 0
             payments_count = 0
 
-            config = self.config
-            if config and config.should_enable_tasks():
-                try:
-                    from django_cfg.modules.django_tasks import extend_constance_config_with_tasks
-                    tasks_fields = extend_constance_config_with_tasks()
-                    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,
-                    )
-                    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,
-                    )
-                    payments_fields = get_django_cfg_payments_constance_fields()
-                    payments_count = len(payments_fields)
-                except:
-                    pass
+            try:
+                from django_cfg.modules.base import BaseCfgModule
+                base_module = BaseCfgModule()
+
+                if base_module.is_extension_enabled("knowbase"):
+                    try:
+                        from extensions.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 base_module.is_extension_enabled("payments"):
+                    try:
+                        from extensions.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
+            except:
+                pass
 
             summary_table.add_row("User Defined", f"[blue]{user_fields}[/blue]")
             if tasks_count > 0:
@@ -580,9 +611,9 @@ class StartupDisplayManager(BaseDisplayManager):
             self.console.print(integrated_panel)
 
         except Exception as e:
-            import traceback
             print(f"❌ ERROR in _display_constance_integrated_block: {e}")
             traceback.print_exc()
+            exit(1)
 
     def _display_constance_details(self):
         """Display detailed Constance configuration information."""
@@ -600,9 +631,9 @@ class StartupDisplayManager(BaseDisplayManager):
             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()
+            exit(1)
 
     def _display_constance_summary(self, constance_config, all_fields):
         """Display summary of Constance fields by source."""
@@ -611,40 +642,36 @@ class StartupDisplayManager(BaseDisplayManager):
             user_fields = len(constance_config.fields)  # User-defined fields
             app_fields = constance_config._get_app_constance_fields()
 
-            # Count by app
+            # Count by app (extensions are now auto-discovered)
             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():
-                try:
-                    from django_cfg.modules.django_tasks import extend_constance_config_with_tasks
-                    tasks_fields = extend_constance_config_with_tasks()
-                    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,
-                    )
-                    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,
-                    )
-                    payments_fields = get_django_cfg_payments_constance_fields()
-                    payments_count = len(payments_fields)
-                except:
-                    pass
+            try:
+                from django_cfg.modules.base import BaseCfgModule
+                base_module = BaseCfgModule()
+
+                if base_module.is_extension_enabled("knowbase"):
+                    try:
+                        from extensions.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 base_module.is_extension_enabled("payments"):
+                    try:
+                        from extensions.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
+            except:
+                pass
 
             # Create summary table
             summary_table = self.create_table()
@@ -671,16 +698,16 @@ class StartupDisplayManager(BaseDisplayManager):
             self.console.print(summary_panel)
 
         except Exception as e:
-            import traceback
             print(f"❌ ERROR in _display_constance_summary: {e}")
             traceback.print_exc()
+            exit(1)
 
     def _display_openapi_client_info(self):
         """Display Django Client (OpenAPI) information."""
         try:
-            from django_cfg.modules.django_client.core.config.service import DjangoOpenAPI
+            from django_cfg.modules.django_client.core.config.service import get_openapi_service
 
-            service = DjangoOpenAPI.instance()
+            service = get_openapi_service()
             if not service.config or not service.config.enabled:
                 return
 
@@ -708,8 +735,11 @@ class StartupDisplayManager(BaseDisplayManager):
         except ImportError:
             # Django Client not available
             pass
-        except Exception:
-            pass
+        except Exception as e:
+            print(f"❌ ERROR in _display_openapi_client_info: {e}")
+            print("🔍 TRACEBACK:")
+            traceback.print_exc()
+            exit(1)
 
     def _display_commands_info(self):
         """Display management commands information."""
@@ -745,9 +775,9 @@ class StartupDisplayManager(BaseDisplayManager):
             self._display_commands_breakdown()
 
         except Exception as e:
-            import traceback
             print(f"❌ ERROR in _display_commands_info: {e}")
             traceback.print_exc()
+            exit(1)
 
     def _display_commands_breakdown(self):
         """Display detailed commands breakdown."""
@@ -845,6 +875,56 @@ class StartupDisplayManager(BaseDisplayManager):
                 self.console.print(project_panel)
 
         except Exception as e:
-            import traceback
             print(f"❌ ERROR in _display_commands_breakdown: {e}")
             traceback.print_exc()
+            exit(1)
+
+    def _get_startup_time(self) -> str:
+        """
+        Get formatted startup time from timer.
+
+        Returns:
+            Formatted startup time string or None
+        """
+        try:
+            from ..timing import get_django_startup_time
+            return get_django_startup_time()
+        except ImportError:
+            return None
+
+    def _display_logging_info(self):
+        """Display logging paths info."""
+        try:
+            import os
+            tmp_disabled = os.getenv('DJANGO_LOG_TO_TMP', 'true').lower() in ('false', '0', 'no')
+
+            log_info = Text("📝 Logs → ", style="dim")
+            log_info.append("./logs/", style="cyan")
+            if not tmp_disabled:
+                log_info.append(" | ", style="dim")
+                log_info.append("/tmp/djangocfg/", style="green")
+                log_info.append(" (tail -f /tmp/djangocfg/debug.log)", style="bright_blue dim")
+            log_info.append(" • ", style="dim")
+            log_info.append("from django_cfg.utils import get_logger", style="yellow dim")
+
+            self.console.print(log_info)
+        except Exception:
+            pass
+
+    def _display_ai_hints(self, mode: str = "short"):
+        """
+        Display AI development hints.
+
+        Args:
+            mode: "short" for compact view, "full" for detailed view
+        """
+        try:
+            # Check if AI hints are enabled in config
+            if self.config and hasattr(self.config, 'show_ai_hints'):
+                if not self.config.show_ai_hints:
+                    return
+
+            self.ai_hints_manager.display_ai_hints(mode=mode)
+        except Exception as e:
+            # Don't crash on AI hints error, just skip
+            pass

django_cfg/core/integration/timing.py

@@ -0,0 +1,151 @@
+"""
+Timing utilities for tracking server startup and initialization times.
+
+This module provides utilities to track timing information for Django and gRPC
+server startup processes.
+"""
+
+import time
+from typing import Optional
+
+
+class ServerStartupTimer:
+    """
+    Track server startup timing information.
+
+    Usage:
+        timer = ServerStartupTimer()
+        # ... server initialization ...
+        elapsed = timer.elapsed()
+        formatted = timer.format_elapsed()
+    """
+
+    def __init__(self):
+        """Initialize timer with current timestamp."""
+        self._start_time = time.time()
+
+    def elapsed(self) -> float:
+        """
+        Get elapsed time in seconds.
+
+        Returns:
+            Elapsed time in seconds as a float
+        """
+        return time.time() - self._start_time
+
+    def format_elapsed(self, decimals: int = 2) -> str:
+        """
+        Format elapsed time as a human-readable string.
+
+        Args:
+            decimals: Number of decimal places for seconds (default: 2)
+
+        Returns:
+            Formatted string like "1.23s" or "12.34s"
+        """
+        elapsed = self.elapsed()
+        return f"{elapsed:.{decimals}f}s"
+
+    def format_elapsed_detailed(self) -> str:
+        """
+        Format elapsed time with detailed breakdown.
+
+        Returns:
+            Formatted string like "1m 23.45s" or "2.34s"
+        """
+        elapsed = self.elapsed()
+
+        if elapsed >= 60:
+            # Show minutes and seconds
+            minutes = int(elapsed // 60)
+            seconds = elapsed % 60
+            return f"{minutes}m {seconds:.2f}s"
+        else:
+            # Just seconds
+            return f"{elapsed:.2f}s"
+
+
+# Global startup timer for Django server
+_django_startup_timer: Optional[ServerStartupTimer] = None
+
+# Global startup timer for gRPC server
+_grpc_startup_timer: Optional[ServerStartupTimer] = None
+
+
+def start_django_timer() -> ServerStartupTimer:
+    """
+    Start tracking Django server startup time.
+
+    Returns:
+        ServerStartupTimer instance
+    """
+    global _django_startup_timer
+    _django_startup_timer = ServerStartupTimer()
+    return _django_startup_timer
+
+
+def start_grpc_timer() -> ServerStartupTimer:
+    """
+    Start tracking gRPC server startup time.
+
+    Returns:
+        ServerStartupTimer instance
+    """
+    global _grpc_startup_timer
+    _grpc_startup_timer = ServerStartupTimer()
+    return _grpc_startup_timer
+
+
+def get_django_timer() -> Optional[ServerStartupTimer]:
+    """
+    Get Django server startup timer.
+
+    Returns:
+        ServerStartupTimer instance or None if not started
+    """
+    return _django_startup_timer
+
+
+def get_grpc_timer() -> Optional[ServerStartupTimer]:
+    """
+    Get gRPC server startup timer.
+
+    Returns:
+        ServerStartupTimer instance or None if not started
+    """
+    return _grpc_startup_timer
+
+
+def get_django_startup_time() -> Optional[str]:
+    """
+    Get formatted Django server startup time.
+
+    Returns:
+        Formatted string like "1.23s" or None if timer not started
+    """
+    if _django_startup_timer:
+        return _django_startup_timer.format_elapsed()
+    return None
+
+
+def get_grpc_startup_time() -> Optional[str]:
+    """
+    Get formatted gRPC server startup time.
+
+    Returns:
+        Formatted string like "1.23s" or None if timer not started
+    """
+    if _grpc_startup_timer:
+        return _grpc_startup_timer.format_elapsed()
+    return None
+
+
+__all__ = [
+    'ServerStartupTimer',
+    'start_django_timer',
+    'start_grpc_timer',
+    'get_django_timer',
+    'get_grpc_timer',
+    'get_django_startup_time',
+    'get_grpc_startup_time',
+]