django-cfg 1.2.31__py3-none-any.whl → 1.3.1__py3-none-any.whl

django_cfg/core/integration/display/base.py

@@ -0,0 +1,157 @@
+"""
+Base display manager for Django CFG startup information.
+"""
+
+from typing import Optional, Dict, Any, List
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.columns import Columns
+from rich.text import Text
+from rich.align import Align
+
+# Panel width configuration - use fixed widths for consistent layout
+CONSOLE_WIDTH = 120  # Console width that fits most terminals
+MAIN_PANEL_WIDTH = CONSOLE_WIDTH  # Full width panels
+HALF_PANEL_WIDTH = (CONSOLE_WIDTH - 10) // 2  # 50% width for columns (minus borders/padding)
+
+
+class BaseDisplayManager:
+    """Base class for all display managers."""
+    
+    def __init__(self, config=None):
+        """Initialize display manager with config."""
+        self.config = config or self._get_current_config()
+        self.console = Console()
+    
+    def _get_current_config(self):
+        """Get current Django CFG configuration."""
+        try:
+            from django_cfg.core.config import get_current_config
+            return get_current_config()
+        except Exception:
+            return None
+    
+    def get_base_url(self, *paths) -> str:
+        """Get base URL for API endpoints with optional path components."""
+        if self.config and hasattr(self.config, 'api_url'):
+            base = self.config.api_url.rstrip('/')
+        else:
+            base = "http://localhost:8000"
+        
+        if paths:
+            # Join all path components
+            path_parts = []
+            for path in paths:
+                if path:
+                    path_parts.append(str(path).strip('/'))
+            
+            if path_parts:
+                return f"{base}/{'/'.join(path_parts)}/"
+        
+        return base
+    
+    def get_environment_style(self):
+        """Get environment styling (panel_style, env_emoji, env_color)."""
+        if not self.config:
+            return "yellow", "🧪", "yellow"
+        
+        if self.config.is_development:
+            return "green", "🚧", "green"
+        elif self.config.is_production:
+            return "red", "🚀", "red"
+        else:
+            return "yellow", "🧪", "yellow"
+    
+    def get_version(self) -> str:
+        """Get Django CFG version."""
+        try:
+            from django_cfg import __version__
+            return __version__
+        except ImportError:
+            return "unknown"
+    
+    def create_panel(self, content, title: str, border_style: str = "blue", 
+                    width: Optional[int] = None, expand: bool = False) -> Panel:
+        """Create a standardized panel with fixed width by default."""
+        # Use MAIN_PANEL_WIDTH by default for consistent layout
+        panel_width = width if width is not None else MAIN_PANEL_WIDTH
+        
+        return Panel(
+            content,
+            title=title,
+            border_style=border_style,
+            width=panel_width,
+            expand=expand,
+            padding=(1, 2)
+        )
+    
+    def create_full_width_panel(self, content, title: str, border_style: str = "blue") -> Panel:
+        """Create a panel that spans the full width (same as two columns)."""
+        # Wrap in a table to match the width of two-column layout
+        wrapper_table = Table(show_header=False, box=None, padding=(0, 0), width=MAIN_PANEL_WIDTH)
+        wrapper_table.add_column("Content", width=MAIN_PANEL_WIDTH, justify="left")
+        
+        panel = Panel(
+            content,
+            title=title,
+            border_style=border_style,
+            expand=True,
+            padding=(1, 2)
+        )
+        
+        wrapper_table.add_row(panel)
+        return wrapper_table
+    
+    def create_table(self, title: str = None, show_header: bool = False) -> Table:
+        """Create a standardized table."""
+        table = Table(title=title, show_header=show_header, box=None)
+        return table
+    
+    def print_panel(self, panel: Panel, centered: bool = False):
+        """Print a panel, optionally centered."""
+        if centered:
+            self.console.print(Align.center(panel))
+        else:
+            self.console.print(panel)
+    
+    def print_columns(self, panels: List[Panel], equal: bool = True, expand: bool = True):
+        """Print panels in columns."""
+        if panels:
+            self.console.print(Columns(panels, equal=equal, expand=expand))
+    
+    def print_two_column_table(self, left_content: str, right_content: str, 
+                              left_title: str = "", right_title: str = "",
+                              left_style: str = "blue", right_style: str = "green"):
+        """Print content in a proper 50/50 two-column layout with panels."""
+        # Create panels that will expand to fill table cells
+        left_panel = Panel(
+            left_content,
+            title=left_title,
+            border_style=left_style,
+            expand=True,
+            padding=(1, 1)
+        )
+        
+        right_panel = Panel(
+            right_content,
+            title=right_title,
+            border_style=right_style,
+            expand=True,
+            padding=(1, 1)
+        )
+        
+        # Use a table to force exact positioning
+        wrapper_table = Table(show_header=False, box=None, padding=(0, 0), width=MAIN_PANEL_WIDTH)
+        wrapper_table.add_column("Left", width=HALF_PANEL_WIDTH, justify="left")
+        wrapper_table.add_column("Right", width=HALF_PANEL_WIDTH, justify="left")
+        
+        # Add panels as table cells
+        wrapper_table.add_row(left_panel, right_panel)
+        
+        self.console.print(wrapper_table)
+    
+    def print_spacing(self, lines: int = 1):
+        """Print empty lines for spacing."""
+        for _ in range(lines):
+            self.console.print()

django_cfg/core/integration/display/ngrok.py

@@ -0,0 +1,164 @@
+"""
+Ngrok display manager for Django CFG.
+"""
+
+from typing import Optional
+from .base import BaseDisplayManager, MAIN_PANEL_WIDTH
+
+
+class NgrokDisplayManager(BaseDisplayManager):
+    """Manager for displaying ngrok tunnel information."""
+    
+    def display_tunnel_info(self, tunnel_url: str):
+        """Display active ngrok tunnel information."""
+        try:
+            if not self._is_ngrok_configured():
+                return
+            
+            ngrok_service = self._get_ngrok_service()
+            if not ngrok_service:
+                return
+            
+            # Create ngrok info table
+            ngrok_table = self.create_table()
+            ngrok_table.add_column("Key", style="cyan", no_wrap=True)
+            ngrok_table.add_column("Value", style="bright_white")
+            
+            # Add tunnel information
+            ngrok_table.add_row("🌐 Tunnel URL:", tunnel_url)
+            
+            # Add webhook URL example
+            webhook_url = ngrok_service.get_webhook_url()
+            ngrok_table.add_row("🔗 Webhook URL:", webhook_url)
+            
+            # Add API URL
+            api_url = ngrok_service.get_api_url()
+            ngrok_table.add_row("🚀 API URL:", api_url)
+            
+            # Add environment variables info
+            ngrok_table.add_row("📝 Env Variables:", "NGROK_URL, DJANGO_NGROK_URL set")
+            
+            # Add domain info if configured
+            if self.config.ngrok.tunnel.domain:
+                ngrok_table.add_row("🏷️  Custom Domain:", self.config.ngrok.tunnel.domain)
+            
+            # Add auth info
+            if self.config.ngrok.auth.get_authtoken():
+                ngrok_table.add_row("🔐 Auth Token:", "✅ Configured")
+            else:
+                ngrok_table.add_row("🔐 Auth Token:", "❌ Not configured (limited features)")
+            
+            # Create panel with ngrok info
+            ngrok_panel = self.create_panel(
+                ngrok_table,
+                title="🚇 [bold green]Ngrok Tunnel Active[/bold green]",
+                border_style="green",
+                width=MAIN_PANEL_WIDTH
+            )
+            
+            # Print the panel (not centered to respect width)
+            self.print_spacing()
+            self.console.print(ngrok_panel)
+            self.print_spacing()
+            
+        except Exception:
+            # Silently fail - ngrok info is not critical
+            pass
+    
+    def display_config_status(self):
+        """Display ngrok configuration status when tunnel is not active."""
+        try:
+            if not self._is_ngrok_configured():
+                return
+            
+            ngrok_service = self._get_ngrok_service()
+            if not ngrok_service:
+                return
+            
+            # Create ngrok config status table
+            status_table = self.create_table()
+            status_table.add_column("Key", style="cyan", no_wrap=True)
+            status_table.add_column("Value", style="bright_white")
+            
+            # Add configuration status
+            status_table.add_row("🔧 Configuration:", "✅ Enabled")
+            
+            # Add auth status
+            if self.config.ngrok.auth.get_authtoken():
+                status_table.add_row("🔐 Auth Token:", "✅ Configured")
+            else:
+                status_table.add_row("🔐 Auth Token:", "❌ Not configured")
+            
+            # Add domain info if configured
+            if self.config.ngrok.tunnel.domain:
+                status_table.add_row("🏷️  Custom Domain:", self.config.ngrok.tunnel.domain)
+            
+            # Add auto-start status
+            if self.config.ngrok.auto_start:
+                status_table.add_row("🚀 Auto Start:", "✅ Enabled")
+            else:
+                status_table.add_row("🚀 Auto Start:", "❌ Disabled")
+            
+            # Add usage hint
+            status_table.add_row("💡 Usage:", "Run 'pnpm manage.py runserver_ngrok' to start tunnel")
+            
+            # Create panel with ngrok config status - full width
+            ngrok_panel = self.create_full_width_panel(
+                status_table,
+                title="🚇 [bold yellow]Ngrok Ready (Not Active)[/bold yellow]",
+                border_style="yellow"
+            )
+            
+            # Print the panel (not centered to respect width)
+            self.print_spacing()
+            self.console.print(ngrok_panel)
+            self.print_spacing()
+            
+        except Exception:
+            # Silently fail - ngrok config status is not critical
+            pass
+    
+    def display_if_active(self):
+        """Display ngrok information if configured and check if active."""
+        if not self._is_ngrok_configured():
+            return
+        
+        ngrok_service = self._get_ngrok_service()
+        if not ngrok_service:
+            return
+        
+        # Check if tunnel is active or available from environment
+        tunnel_url = ngrok_service.get_tunnel_url()
+        env_url = ngrok_service.get_tunnel_url_from_env()
+        
+        # IMPORTANT: During Django startup, ngrok tunnel may not be active yet
+        # Only show active tunnel info if we actually have a tunnel URL
+        # Otherwise, show config status (ready but not active)
+        active_url = None
+        
+        if tunnel_url:
+            # Active tunnel found from manager
+            active_url = tunnel_url
+        elif env_url:
+            # Environment URL found (tunnel was started in this process)
+            active_url = env_url
+        
+        if active_url:
+            self.display_tunnel_info(active_url)
+        else:
+            self.display_config_status()
+    
+    def _is_ngrok_configured(self) -> bool:
+        """Check if ngrok is configured."""
+        return (self.config and 
+                hasattr(self.config, 'ngrok') and 
+                self.config.ngrok and 
+                self.config.ngrok.enabled)
+    
+    def _get_ngrok_service(self):
+        """Get ngrok service instance."""
+        try:
+            from django_cfg.modules.django_ngrok import get_ngrok_service
+            return get_ngrok_service()
+        except Exception:
+            return None