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

django_cfg/core/integration/commands_collector.py

@@ -0,0 +1,239 @@
+"""
+Management commands collector for django-cfg.
+
+Collects and groups all available Django management commands.
+"""
+
+import os
+from pathlib import Path
+from typing import Dict, List, Optional, Set
+from collections import defaultdict
+
+try:
+    from django.core.management import get_commands
+    from django.apps import apps
+    DJANGO_AVAILABLE = True
+except ImportError:
+    DJANGO_AVAILABLE = False
+
+
+class CommandsCollector:
+    """
+    Collects and organizes Django management commands by source.
+    """
+    
+    def __init__(self):
+        """Initialize commands collector."""
+        self.django_cfg_path = Path(__file__).parent.parent.parent
+        self.commands_cache = None
+    
+    def get_all_commands(self) -> Dict[str, Dict[str, List[str]]]:
+        """
+        Get all available commands grouped by source.
+        
+        Returns:
+            Dictionary with command groups:
+            {
+                'django_cfg_core': {'Core Commands': [...]},
+                'django_cfg_apps': {'App Name': [...], ...},
+                'project_commands': {'Project Commands': [...]}
+            }
+        """
+        if self.commands_cache is not None:
+            return self.commands_cache
+        
+        commands = {
+            'django_cfg_core': {},
+            'django_cfg_apps': {},
+            'project_commands': {}
+        }
+        
+        # Get Django-CFG core commands
+        core_commands = self._get_django_cfg_core_commands()
+        if core_commands:
+            commands['django_cfg_core']['Core Commands'] = sorted(core_commands)
+        
+        # Get Django-CFG app commands
+        app_commands = self._get_django_cfg_app_commands()
+        for app_name, app_cmds in app_commands.items():
+            if app_cmds:
+                commands['django_cfg_apps'][app_name] = sorted(app_cmds)
+        
+        # Get project commands (if Django is available)
+        if DJANGO_AVAILABLE:
+            project_commands = self._get_project_commands()
+            if project_commands:
+                commands['project_commands']['Project Commands'] = sorted(project_commands)
+        
+        self.commands_cache = commands
+        return commands
+    
+    def _get_django_cfg_core_commands(self) -> List[str]:
+        """Get Django-CFG core management commands."""
+        commands = []
+        core_commands_path = self.django_cfg_path / "management" / "commands"
+        
+        if core_commands_path.exists():
+            for file_path in core_commands_path.glob("*.py"):
+                if file_path.name != "__init__.py":
+                    command_name = file_path.stem
+                    commands.append(command_name)
+        
+        return commands
+    
+    def _get_django_cfg_app_commands(self) -> Dict[str, List[str]]:
+        """Get Django-CFG app-specific management commands."""
+        app_commands = defaultdict(list)
+        apps_path = self.django_cfg_path / "apps"
+        
+        if not apps_path.exists():
+            return dict(app_commands)
+        
+        for app_dir in apps_path.iterdir():
+            if app_dir.is_dir() and not app_dir.name.startswith('.') and app_dir.name != '__pycache__':
+                # Skip @old directory
+                if app_dir.name.startswith('@'):
+                    continue
+                
+                commands_path = app_dir / "management" / "commands"
+                if commands_path.exists():
+                    app_name = app_dir.name.title()
+                    
+                    for file_path in commands_path.glob("*.py"):
+                        if file_path.name != "__init__.py":
+                            command_name = file_path.stem
+                            app_commands[app_name].append(command_name)
+        
+        return dict(app_commands)
+    
+    def _get_project_commands(self) -> List[str]:
+        """Get project-specific management commands (excluding Django-CFG)."""
+        if not DJANGO_AVAILABLE:
+            return []
+        
+        try:
+            all_commands = get_commands()
+            django_cfg_commands = set()
+            
+            # Collect all Django-CFG commands
+            core_commands = self._get_django_cfg_core_commands()
+            django_cfg_commands.update(core_commands)
+            
+            app_commands = self._get_django_cfg_app_commands()
+            for app_cmds in app_commands.values():
+                django_cfg_commands.update(app_cmds)
+            
+            # Filter out Django-CFG commands and Django built-ins
+            django_builtin_commands = {
+                'check', 'compilemessages', 'createcachetable', 'dbshell',
+                'diffsettings', 'dumpdata', 'flush', 'inspectdb', 'loaddata',
+                'makemessages', 'makemigrations', 'migrate', 'optimizemigration',
+                'runserver', 'shell', 'showmigrations', 'sqlflush', 'sqlmigrate',
+                'sqlsequencereset', 'squashmigrations', 'startapp', 'startproject',
+                'test', 'testserver', 'collectstatic', 'findstatic', 'clearsessions',
+                'createsuperuser', 'changepassword'
+            }
+            
+            project_commands = []
+            for cmd_name in all_commands.keys():
+                if (cmd_name not in django_cfg_commands and 
+                    cmd_name not in django_builtin_commands):
+                    project_commands.append(cmd_name)
+            
+            return project_commands
+            
+        except Exception:
+            return []
+    
+    def get_command_description(self, command_name: str) -> Optional[str]:
+        """
+        Get command description from its help text.
+        
+        Args:
+            command_name: Name of the command
+            
+        Returns:
+            Command description or None if not available
+        """
+        if not DJANGO_AVAILABLE:
+            return None
+        
+        try:
+            from django.core.management import load_command_class
+            from django.core.management.base import CommandError
+            
+            try:
+                command = load_command_class(None, command_name)
+                return getattr(command, 'help', None) or None
+            except (CommandError, ImportError, AttributeError):
+                return None
+        except Exception:
+            return None
+    
+    def get_commands_with_descriptions(self) -> Dict[str, Dict[str, Dict[str, Optional[str]]]]:
+        """
+        Get all commands with their descriptions.
+        
+        Returns:
+            Dictionary with commands and descriptions:
+            {
+                'django_cfg_core': {'Core Commands': {'cmd': 'description', ...}},
+                'django_cfg_apps': {'App Name': {'cmd': 'description', ...}, ...},
+                'project_commands': {'Project Commands': {'cmd': 'description', ...}}
+            }
+        """
+        all_commands = self.get_all_commands()
+        commands_with_desc = {}
+        
+        for category, groups in all_commands.items():
+            commands_with_desc[category] = {}
+            
+            for group_name, commands in groups.items():
+                commands_with_desc[category][group_name] = {}
+                
+                for cmd in commands:
+                    desc = self.get_command_description(cmd)
+                    commands_with_desc[category][group_name][cmd] = desc
+        
+        return commands_with_desc
+
+
+# Global instance
+_commands_collector = CommandsCollector()
+
+
+def get_all_commands() -> Dict[str, Dict[str, List[str]]]:
+    """
+    Get all available Django management commands grouped by source.
+    
+    Returns:
+        Dictionary with command groups
+    """
+    return _commands_collector.get_all_commands()
+
+
+def get_commands_with_descriptions() -> Dict[str, Dict[str, Dict[str, Optional[str]]]]:
+    """
+    Get all commands with their descriptions.
+    
+    Returns:
+        Dictionary with commands and descriptions
+    """
+    return _commands_collector.get_commands_with_descriptions()
+
+
+def get_command_count() -> int:
+    """
+    Get total count of available commands.
+    
+    Returns:
+        Total number of commands
+    """
+    all_commands = get_all_commands()
+    total = 0
+    
+    for category in all_commands.values():
+        for commands in category.values():
+            total += len(commands)
+    
+    return total

django_cfg/core/integration/display/__init__.py

@@ -0,0 +1,15 @@
+"""
+Django CFG Display System.
+
+Modular, class-based display system for startup information.
+"""
+
+from .base import BaseDisplayManager
+from .startup import StartupDisplayManager
+from .ngrok import NgrokDisplayManager
+
+__all__ = [
+    "BaseDisplayManager",
+    "StartupDisplayManager", 
+    "NgrokDisplayManager",
+]

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