django-cfg 1.4.10__py3-none-any.whl → 1.4.13__py3-none-any.whl

django_cfg/management/commands/show_config.py

@@ -1,225 +1,22 @@
 """
-Django management command to show current configuration.
+Django-CFG wrapper for show_config command.
+
+This is a simple alias for django_admin.management.commands.show_config.
+All logic is in django_admin module.
 
 Usage:
     python manage.py show_config
     python manage.py show_config --format json
+    python manage.py show_config --include-secrets
 """
 
-import json
-import os
-from django.core.management.base import BaseCommand
-from django.conf import settings
-from django_cfg.modules.django_logging import get_logger
-
-logger = get_logger('show_config')
-
-
-class Command(BaseCommand):
-    # Web execution metadata
-    web_executable = True
-    requires_input = False
-    is_destructive = False
-
-    help = 'Show Django Config configuration'
-
-    def add_arguments(self, parser):
-        parser.add_argument(
-            '--format',
-            choices=['table', 'json'],
-            default='table',
-            help='Output format (default: table)',
-        )
-        parser.add_argument(
-            '--include-secrets',
-            action='store_true',
-            help='Include sensitive information (use carefully)',
-        )
-
-    def handle(self, *args, **options):
-        """Show configuration in requested format."""
-        logger.info("Starting show_config command")
-        try:
-            # Get the config instance from Django settings
-            config = self._get_config_instance()
-            logger.info("Successfully retrieved configuration instance")
-            
-            if options['format'] == 'json':
-                logger.info("Displaying configuration in JSON format")
-                self._show_json_format(config, options['include_secrets'])
-            else:
-                logger.info("Displaying configuration in table format")
-                self._show_table_format(config, options['include_secrets'])
-                
-            logger.info("show_config command completed successfully")
-        except Exception as e:
-            error_msg = f'Failed to show configuration: {e}'
-            logger.error(error_msg, exc_info=True)
-            self.stdout.write(
-                self.style.ERROR(f'❌ {error_msg}')
-            )
+from django_cfg.modules.django_admin.management.commands.show_config import Command as ShowConfigCommand
 
-    def _get_config_instance(self):
-        """Get the DjangoConfig instance from Django settings."""
-        # Try to get config from settings module
-        settings_module = os.environ.get('DJANGO_SETTINGS_MODULE')
-        if not settings_module:
-            raise ValueError("DJANGO_SETTINGS_MODULE environment variable not set")
-        
-        # Import the settings module and get the config
-        import importlib
-        settings_mod = importlib.import_module(settings_module)
-        
-        if hasattr(settings_mod, 'config'):
-            return settings_mod.config
-        else:
-            # Fallback: create a minimal config from Django settings
-            from django_cfg import DjangoConfig
-            return DjangoConfig(
-                project_name=getattr(settings, 'PROJECT_NAME', 'Django Project'),
-                secret_key=settings.SECRET_KEY,
-                debug=settings.DEBUG,
-                allowed_hosts=settings.ALLOWED_HOSTS,
-            )
 
-    def _show_table_format(self, config, include_secrets=False):
-        """Show configuration in table format."""
-        self.stdout.write(
-            self.style.HTTP_INFO('🚀 Django Config - Current Configuration')
-        )
-        self.stdout.write('=' * 80)
-        
-        # Project section
-        self.stdout.write(self.style.SUCCESS('\n📋 Project'))
-        self.stdout.write('-' * 40)
-        project_data = [
-            ('Name', config.project_name),
-            ('Version', getattr(config, 'project_version', 'N/A')),
-            ('Description', getattr(config, 'project_description', 'N/A')),
-        ]
-        
-        for key, value in project_data:
-            self.stdout.write(f'  {key:<20}: {value}')
-        
-        # Environment section
-        self.stdout.write(self.style.SUCCESS('\n🌍 Environment'))
-        self.stdout.write('-' * 40)
-        env_data = [
-            ('Environment', getattr(config, 'env_mode', 'auto-detected')),
-            ('Debug Mode', config.debug),
-            ('Security Domains', ', '.join(config.security_domains) if config.security_domains else 'None'),
-        ]
-        
-        if include_secrets:
-            env_data.append(('Secret Key', config.secret_key[:20] + '...'))
-        else:
-            env_data.append(('Secret Key', '[HIDDEN]'))
-        
-        for key, value in env_data:
-            self.stdout.write(f'  {key:<20}: {value}')
-        
-        # Database section
-        self.stdout.write(self.style.SUCCESS('\n🗄️  Databases'))
-        self.stdout.write('-' * 40)
-        
-        for db_name, db_config in config.databases.items():
-            self.stdout.write(f'  {db_name}:')
-            self.stdout.write(f'    Engine: {db_config.engine}')
-            if include_secrets:
-                self.stdout.write(f'    Name: {db_config.name}')
-                self.stdout.write(f'    Host: {db_config.host}')
-                self.stdout.write(f'    Port: {db_config.port}')
-            else:
-                self.stdout.write(f'    Name: [HIDDEN]')
-                self.stdout.write(f'    Host: [HIDDEN]')
-                self.stdout.write(f'    Port: [HIDDEN]')
-        
-        # Cache section
-        cache_configured = False
-        if hasattr(config, 'cache_default') and config.cache_default:
-            cache_configured = True
-        
-        if cache_configured:
-            self.stdout.write(self.style.SUCCESS('\n⚡ Cache'))
-            self.stdout.write('-' * 40)
-            cache_data = [
-                ('Default Cache', 'Configured'),
-                ('Sessions Cache', 'Configured' if hasattr(config, 'cache_sessions') and config.cache_sessions else 'Not configured'),
-            ]
-            
-            for key, value in cache_data:
-                self.stdout.write(f'  {key:<20}: {value}')
-        
-        # Services section
-        services_configured = []
-        if hasattr(config, 'email') and config.email:
-            services_configured.append(('Email', 'Configured'))
-        if hasattr(config, 'telegram') and config.telegram:
-            services_configured.append(('Telegram', 'Configured'))
-        
-        if services_configured:
-            self.stdout.write(self.style.SUCCESS('\n🔧 Services'))
-            self.stdout.write('-' * 40)
-            
-            for key, value in services_configured:
-                self.stdout.write(f'  {key:<20}: {value}')
-        
-        # Apps section
-        if hasattr(config, 'project_apps') and config.project_apps:
-            self.stdout.write(self.style.SUCCESS('\n📦 Project Apps'))
-            self.stdout.write('-' * 40)
-            
-            for app in config.project_apps:
-                self.stdout.write(f'  • {app}')
-        
-        # Custom Middleware section
-        if hasattr(config, 'custom_middleware') and config.custom_middleware:
-            self.stdout.write(self.style.SUCCESS('\n🛡️  Custom Middleware'))
-            self.stdout.write('-' * 40)
-            
-            for middleware in config.custom_middleware:
-                self.stdout.write(f'  • {middleware}')
-        
-        self.stdout.write('\n' + '=' * 80)
+class Command(ShowConfigCommand):
+    """
+    Alias for show_config command.
 
-    def _show_json_format(self, config, include_secrets=False):
-        """Show configuration in JSON format."""
-        config_data = {
-            'project': {
-                'name': config.project_name,
-                'version': getattr(config, 'project_version', None),
-                'description': getattr(config, 'project_description', None),
-            },
-            'environment': {
-                'environment': getattr(config, 'env_mode', 'auto-detected'),
-                'debug': config.debug,
-                'allowed_hosts': config.allowed_hosts,
-            },
-            'databases': {},
-            'cache': {
-                'default_configured': hasattr(config, 'cache_default') and config.cache_default is not None,
-                'sessions_configured': hasattr(config, 'cache_sessions') and config.cache_sessions is not None,
-            },
-            'services': {
-                'email_configured': hasattr(config, 'email') and config.email is not None,
-                'telegram_configured': hasattr(config, 'telegram') and config.telegram is not None,
-            },
-            'apps': {
-                'project_apps': getattr(config, 'project_apps', []),
-                'custom_middleware': getattr(config, 'custom_middleware', []),
-            }
-        }
-        
-        # Add database info
-        for db_name, db_config in config.databases.items():
-            config_data['databases'][db_name] = {
-                'engine': db_config.engine,
-                'name': db_config.name if include_secrets else '[HIDDEN]',
-                'host': db_config.host if include_secrets else '[HIDDEN]',
-                'port': db_config.port if include_secrets else '[HIDDEN]',
-            }
-        
-        if include_secrets:
-            config_data['environment']['secret_key'] = config.secret_key
-        
-        self.stdout.write(json.dumps(config_data, indent=2, default=str))
+    Simply inherits from ShowConfigCommand without any changes.
+    """
+    pass

django_cfg/management/commands/show_urls.py

@@ -1,350 +1,20 @@
 """
-Django management command to display all URL patterns in the project.
-"""
+Django-CFG wrapper for show_urls command.
 
-import re
-from typing import List, Tuple, Optional
-from django.core.management.base import BaseCommand, CommandParser
-from django.urls import get_resolver
-from django.conf import settings
-from django.utils.termcolors import make_style
-from django_cfg.modules.django_logging import get_logger
+This is a simple alias for django_admin.management.commands.show_urls.
+All logic is in django_admin module.
 
-logger = get_logger('show_urls')
+Usage:
+    python manage.py show_urls
+"""
 
+from django_cfg.modules.django_admin.management.commands.show_urls import Command as ShowUrlsCommand
 
-class Command(BaseCommand):
-    """
-    Display all URL patterns in the Django project.
 
-    This command recursively walks through all URL patterns and displays them
-    in a hierarchical format with colors and filtering options.
+class Command(ShowUrlsCommand):
     """
+    Alias for show_urls command.
 
-    # Web execution metadata
-    web_executable = True
-    requires_input = False
-    is_destructive = False
-
-    help = 'Display all URL patterns in the project'
-    
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        
-        # Define color styles
-        self.styles = {
-            'SUCCESS': make_style(opts=('bold',), fg='green'),
-            'WARNING': make_style(opts=('bold',), fg='yellow'),
-            'ERROR': make_style(opts=('bold',), fg='red'),
-            'HTTP_200': make_style(fg='green'),
-            'HTTP_400': make_style(fg='yellow'),
-            'HTTP_500': make_style(fg='red'),
-            'URL': make_style(fg='cyan'),
-            'NAME': make_style(fg='blue'),
-            'INCLUDE': make_style(opts=('bold',), fg='magenta'),
-            'NAMESPACE': make_style(opts=('bold',), fg='yellow'),
-        }
-
-    def add_arguments(self, parser: CommandParser) -> None:
-        """Add command arguments."""
-        parser.add_argument(
-            '--format',
-            choices=['list', 'tree', 'table'],
-            default='tree',
-            help='Output format (default: tree)'
-        )
-        parser.add_argument(
-            '--filter',
-            type=str,
-            help='Filter URLs by pattern (regex supported)'
-        )
-        parser.add_argument(
-            '--namespace',
-            type=str,
-            help='Show URLs only from specific namespace'
-        )
-        parser.add_argument(
-            '--plain',
-            action='store_true',
-            help='Plain output without colors'
-        )
-        parser.add_argument(
-            '--include-unnamed',
-            action='store_true',
-            help='Include URLs without names'
-        )
-        parser.add_argument(
-            '--show-methods',
-            action='store_true',
-            help='Show HTTP methods for each URL'
-        )
-        parser.add_argument(
-            '--show-views',
-            action='store_true',
-            help='Show view functions/classes'
-        )
-
-    def handle(self, *args, **options) -> None:
-        """Main command handler."""
-        logger.info("Starting show_urls command")
-        self.options = options
-        
-        # Disable colors if requested
-        if options['plain'] or options.get('no_color', False):
-            for key in self.styles:
-                self.styles[key] = lambda x: x
-
-        self.stdout.write(
-            self.styles['SUCCESS']('🌐 Django URL Patterns')
-        )
-        self.stdout.write('=' * 50)
-        
-        # Show Django Revolution info if available
-        if hasattr(settings, 'DJANGO_REVOLUTION'):
-            self._show_revolution_info()
-        
-        # Get and display URL patterns
-        resolver = get_resolver()
-        patterns = self._collect_patterns(resolver.url_patterns)
-        
-        # Filter patterns if requested
-        if options['filter']:
-            patterns = self._filter_patterns(patterns, options['filter'])
-        
-        if options['namespace']:
-            patterns = self._filter_by_namespace(patterns, options['namespace'])
-        
-        # Display patterns in requested format
-        if options['format'] == 'list':
-            self._display_list(patterns)
-        elif options['format'] == 'table':
-            self._display_table(patterns)
-        else:
-            self._display_tree(patterns)
-        
-        self.stdout.write(f"\n📊 Total URLs: {len(patterns)}")
-
-    def _show_revolution_info(self) -> None:
-        """Display Django Revolution configuration info."""
-        revolution = settings.DJANGO_REVOLUTION
-        
-        self.stdout.write(
-            self.styles['NAMESPACE']('\n📋 Django Revolution Configuration:')
-        )
-        self.stdout.write(f"  API Prefix: {revolution.get('api_prefix', 'N/A')}")
-        self.stdout.write(f"  Debug: {revolution.get('debug', 'N/A')}")
-        
-        zones = revolution.get('zones', {})
-        if zones:
-            self.stdout.write(f"  Zones: {', '.join(zones.keys())}")
-        self.stdout.write('')
-
-    def _collect_patterns(
-        self, 
-        urlpatterns, 
-        prefix: str = '', 
-        namespace: str = ''
-    ) -> List[Tuple[str, str, str, str, Optional[str]]]:
-        """
-        Recursively collect all URL patterns.
-        
-        Returns list of tuples: (pattern, name, namespace, view, methods)
-        """
-        patterns = []
-        
-        for pattern in urlpatterns:
-            if hasattr(pattern, 'url_patterns'):
-                # This is an include() pattern
-                new_prefix = prefix + str(pattern.pattern)
-                new_namespace = namespace
-                
-                if hasattr(pattern, 'namespace') and pattern.namespace:
-                    new_namespace = (
-                        f"{namespace}:{pattern.namespace}" 
-                        if namespace 
-                        else pattern.namespace
-                    )
-                
-                # Add the include pattern itself
-                patterns.append((
-                    new_prefix,
-                    f"[INCLUDE: {getattr(pattern, 'app_name', 'unknown')}]",
-                    new_namespace,
-                    'include',
-                    None
-                ))
-                
-                # Recursively collect nested patterns
-                patterns.extend(
-                    self._collect_patterns(
-                        pattern.url_patterns, 
-                        new_prefix, 
-                        new_namespace
-                    )
-                )
-            else:
-                # Regular URL pattern
-                full_pattern = prefix + str(pattern.pattern)
-                name = getattr(pattern, 'name', None)
-                view_name = self._get_view_name(pattern)
-                methods = self._get_http_methods(pattern)
-                
-                patterns.append((
-                    full_pattern,
-                    name or '[unnamed]',
-                    namespace,
-                    view_name,
-                    methods
-                ))
-        
-        return patterns
-
-    def _get_view_name(self, pattern) -> str:
-        """Get the view function/class name from a URL pattern."""
-        try:
-            if hasattr(pattern, 'callback'):
-                callback = pattern.callback
-                if hasattr(callback, '__name__'):
-                    return callback.__name__
-                elif hasattr(callback, '__class__'):
-                    return callback.__class__.__name__
-                else:
-                    return str(callback)
-            return 'unknown'
-        except Exception:
-            return 'unknown'
-
-    def _get_http_methods(self, pattern) -> Optional[str]:
-        """Get HTTP methods supported by a URL pattern."""
-        if not self.options['show_methods']:
-            return None
-        
-        try:
-            # Try to get methods from the view
-            if hasattr(pattern, 'callback'):
-                callback = pattern.callback
-                if hasattr(callback, 'cls'):
-                    # DRF ViewSet or APIView
-                    view_class = callback.cls
-                    if hasattr(view_class, 'http_method_names'):
-                        return ', '.join(view_class.http_method_names).upper()
-                elif hasattr(callback, 'view_class'):
-                    # Class-based view
-                    view_class = callback.view_class
-                    if hasattr(view_class, 'http_method_names'):
-                        return ', '.join(view_class.http_method_names).upper()
-            return 'GET, POST, PUT, PATCH, DELETE'  # Default assumption
-        except Exception:
-            return None
-
-    def _filter_patterns(
-        self, 
-        patterns: List[Tuple], 
-        filter_pattern: str
-    ) -> List[Tuple]:
-        """Filter patterns by regex."""
-        try:
-            regex = re.compile(filter_pattern, re.IGNORECASE)
-            return [
-                pattern for pattern in patterns
-                if regex.search(pattern[0]) or regex.search(pattern[1])
-            ]
-        except re.error:
-            self.stdout.write(
-                self.styles['ERROR'](f"Invalid regex pattern: {filter_pattern}")
-            )
-            return patterns
-
-    def _filter_by_namespace(
-        self, 
-        patterns: List[Tuple], 
-        namespace: str
-    ) -> List[Tuple]:
-        """Filter patterns by namespace."""
-        return [
-            pattern for pattern in patterns
-            if pattern[2] and namespace in pattern[2]
-        ]
-
-    def _display_tree(self, patterns: List[Tuple]) -> None:
-        """Display patterns in tree format."""
-        self.stdout.write(self.styles['SUCCESS']('\n🌳 URL Tree:'))
-        self.stdout.write('-' * 30)
-        
-        for pattern, name, namespace, view, methods in patterns:
-            # Format the output
-            if '[INCLUDE:' in name:
-                # Include pattern
-                icon = '📁'
-                pattern_display = self.styles['INCLUDE'](pattern)
-                name_display = self.styles['NAMESPACE'](name)
-            elif name == '[unnamed]' and not self.options['include_unnamed']:
-                continue
-            else:
-                # Regular pattern
-                icon = '🔗'
-                pattern_display = self.styles['URL'](pattern)
-                name_display = self.styles['NAME'](name)
-            
-            # Build the line
-            line = f"{icon} {pattern_display}"
-            if name and name != '[unnamed]':
-                line += f" -> {name_display}"
-            
-            if namespace:
-                line += f" [{self.styles['NAMESPACE'](namespace)}]"
-            
-            if self.options['show_views'] and view and view != 'include':
-                line += f" ({view})"
-            
-            if methods:
-                line += f" [{methods}]"
-            
-            self.stdout.write(line)
-
-    def _display_list(self, patterns: List[Tuple]) -> None:
-        """Display patterns in simple list format."""
-        self.stdout.write(self.styles['SUCCESS']('\n📋 URL List:'))
-        self.stdout.write('-' * 20)
-        
-        for i, (pattern, name, namespace, view, methods) in enumerate(patterns, 1):
-            if name == '[unnamed]' and not self.options['include_unnamed']:
-                continue
-            
-            line = f"{i:3d}. {self.styles['URL'](pattern)}"
-            if name and name != '[unnamed]':
-                line += f" ({self.styles['NAME'](name)})"
-            
-            self.stdout.write(line)
-
-    def _display_table(self, patterns: List[Tuple]) -> None:
-        """Display patterns in table format."""
-        self.stdout.write(self.styles['SUCCESS']('\n📊 URL Table:'))
-        self.stdout.write('-' * 80)
-        
-        # Header
-        headers = ['Pattern', 'Name', 'Namespace', 'View']
-        if self.options['show_methods']:
-            headers.append('Methods')
-        
-        header_line = ' | '.join(f"{h:<20}" for h in headers)
-        self.stdout.write(self.styles['SUCCESS'](header_line))
-        self.stdout.write('-' * len(header_line))
-        
-        # Rows
-        for pattern, name, namespace, view, methods in patterns:
-            if name == '[unnamed]' and not self.options['include_unnamed']:
-                continue
-            
-            row = [
-                pattern[:20],
-                (name or '')[:20],
-                (namespace or '')[:20],
-                (view or '')[:20]
-            ]
-            
-            if self.options['show_methods']:
-                row.append((methods or '')[:20])
-            
-            row_line = ' | '.join(f"{cell:<20}" for cell in row)
-            self.stdout.write(row_line)
+    Simply inherits from ShowUrlsCommand without any changes.
+    """
+    pass