django-cfg 1.4.87__py3-none-any.whl → 1.4.89__py3-none-any.whl

django_cfg/modules/django_dashboard/management/commands/debug_dashboard.py

@@ -1,109 +0,0 @@
-"""
-Management command to debug dashboard rendering.
-
-Renders all dashboard sections and saves them for inspection.
-"""
-
-from django.contrib.auth import get_user_model
-from django.core.management.base import BaseCommand
-from django.test import RequestFactory
-
-from django_cfg.modules.django_dashboard.debug import get_debugger
-from django_cfg.modules.django_dashboard.sections.commands import CommandsSection
-from django_cfg.modules.django_dashboard.sections.overview import OverviewSection
-from django_cfg.modules.django_dashboard.sections.stats import StatsSection
-from django_cfg.modules.django_dashboard.sections.system import SystemSection
-
-
-class Command(BaseCommand):
-    help = "Debug dashboard rendering - saves all sections to disk"
-
-    def add_arguments(self, parser):
-        parser.add_argument(
-            '--section',
-            type=str,
-            choices=['overview', 'stats', 'system', 'commands', 'all'],
-            default='all',
-            help='Which section to render (default: all)'
-        )
-        parser.add_argument(
-            '--user',
-            type=str,
-            help='Username to use for request (default: first superuser)'
-        )
-
-    def handle(self, *args, **options):
-        # Create mock request
-        factory = RequestFactory()
-        request = factory.get('/admin/')
-
-        # Get user for request
-        User = get_user_model()
-        username = options.get('user')
-
-        if username:
-            try:
-                user = User.objects.get(username=username)
-            except User.DoesNotExist:
-                self.stdout.write(
-                    self.style.ERROR(f"User '{username}' not found")
-                )
-                return
-        else:
-            # Use first superuser
-            user = User.objects.filter(is_superuser=True).first()
-            if not user:
-                self.stdout.write(
-                    self.style.WARNING("No superuser found, using anonymous request")
-                )
-
-        if user:
-            request.user = user
-            self.stdout.write(f"Using user: {user.username}")
-
-        # Get debugger
-        debugger = get_debugger()
-        self.stdout.write(f"Saving renders to: {debugger.output_dir}")
-
-        section_choice = options['section']
-        sections = {
-            'overview': OverviewSection,
-            'stats': StatsSection,
-            'system': SystemSection,
-            'commands': CommandsSection,
-        }
-
-        if section_choice == 'all':
-            sections_to_render = sections.items()
-        else:
-            sections_to_render = [(section_choice, sections[section_choice])]
-
-        # Render sections
-        for name, SectionClass in sections_to_render:
-            self.stdout.write(f"\nRendering {name} section...")
-
-            try:
-                section = SectionClass(request)
-                html = section.render()
-
-                # Save render
-                path = debugger.save_section_render(
-                    section_name=name,
-                    html=html,
-                    section_data=section.get_context_data() if hasattr(section, 'get_context_data') else None
-                )
-
-                self.stdout.write(
-                    self.style.SUCCESS(f"✅ {name}: {len(html)} bytes, saved to {path.name}")
-                )
-
-            except Exception as e:
-                self.stdout.write(
-                    self.style.ERROR(f"❌ {name}: {e}")
-                )
-                import traceback
-                traceback.print_exc()
-
-        self.stdout.write(
-            self.style.SUCCESS(f"\n✅ Done! Check renders in: {debugger.output_dir}")
-        )

django_cfg/modules/django_dashboard/sections/__init__.py

@@ -1 +0,0 @@
-"""Dashboard sections package."""

django_cfg/modules/django_dashboard/sections/base.py

@@ -1,129 +0,0 @@
-"""
-Base dashboard section classes.
-
-Provides foundation for dashboard sections following Unfold's pattern.
-"""
-
-from typing import Any, Dict, Optional
-
-from django.http import HttpRequest
-from django.template.loader import render_to_string
-
-
-class DashboardSection:
-    """
-    Base class for dashboard sections.
-
-    Each section is responsible for:
-    - Data collection
-    - Context preparation
-    - Template rendering
-
-    Usage:
-        class MySection(DashboardSection):
-            template_name = "admin/sections/my_section.html"
-
-            def get_context_data(self, **kwargs):
-                context = super().get_context_data(**kwargs)
-                context['custom_data'] = self.get_custom_data()
-                return context
-    """
-
-    template_name: Optional[str] = None
-    title: Optional[str] = None
-    icon: Optional[str] = None
-
-    def __init__(self, request: HttpRequest) -> None:
-        """Initialize section with request context."""
-        self.request = request
-
-    def get_context_data(self, **kwargs) -> Dict[str, Any]:
-        """
-        Get context data for template rendering.
-
-        Override this method to add custom context.
-        """
-        context = {
-            'request': self.request,
-            'section': self,
-        }
-
-        if self.title:
-            context['title'] = self.title
-
-        if self.icon:
-            context['icon'] = self.icon
-
-        context.update(kwargs)
-        return context
-
-    def render(self, **kwargs) -> str:
-        """
-        Render the section template.
-
-        Args:
-            **kwargs: Additional context to pass to template
-
-        Returns:
-            Rendered HTML string
-        """
-        if not self.template_name:
-            raise NotImplementedError(
-                f"{self.__class__.__name__} must define 'template_name' or override render()"
-            )
-
-        context = self.get_context_data(**kwargs)
-        return render_to_string(self.template_name, context=context, request=self.request)
-
-    def __str__(self) -> str:
-        """String representation."""
-        return self.title or self.__class__.__name__
-
-
-class DataSection(DashboardSection):
-    """
-    Section that provides data-driven content.
-
-    Extend this for sections that need to fetch and process data.
-    """
-
-    def get_data(self) -> Any:
-        """
-        Get section data.
-
-        Override this to provide section-specific data.
-        """
-        raise NotImplementedError(
-            f"{self.__class__.__name__} must implement get_data()"
-        )
-
-    def get_context_data(self, **kwargs) -> Dict[str, Any]:
-        """Add data to context."""
-        context = super().get_context_data(**kwargs)
-        context['data'] = self.get_data()
-        return context
-
-
-class CardSection(DashboardSection):
-    """
-    Section rendered as a card component.
-
-    Automatically wraps content in card template.
-    """
-
-    template_name = "admin/components/card.html"
-    content_template: Optional[str] = None
-
-    def get_context_data(self, **kwargs) -> Dict[str, Any]:
-        """Add card-specific context."""
-        context = super().get_context_data(**kwargs)
-
-        # Render content if content_template is provided
-        if self.content_template:
-            context['content'] = render_to_string(
-                self.content_template,
-                context=context,
-                request=self.request
-            )
-
-        return context

django_cfg/modules/django_dashboard/sections/commands.py

@@ -1,33 +0,0 @@
-"""Commands section for dashboard."""
-
-from typing import Any, Dict
-
-from .base import DataSection
-
-
-class CommandsSection(DataSection):
-    """
-    Management commands section.
-    """
-
-    template_name = "admin/sections/commands_section.html"
-    title = "Management Commands"
-    icon = "terminal"
-
-    def get_data(self) -> Dict[str, Any]:
-        """Get commands data."""
-        from django_cfg.modules.django_unfold.callbacks.base import (
-            get_available_commands,
-            get_commands_by_category,
-        )
-
-        commands = get_available_commands()
-        categorized = get_commands_by_category()
-
-        return {
-            'commands': commands,
-            'categories': categorized,
-            'total_commands': len(commands),
-            'core_commands': len([cmd for cmd in commands if cmd.get('is_core')]),
-            'custom_commands': len([cmd for cmd in commands if cmd.get('is_custom')]),
-        }

django_cfg/modules/django_dashboard/sections/documentation.py

@@ -1,393 +0,0 @@
-"""Documentation section for dashboard."""
-
-import inspect
-import os
-from pathlib import Path
-from typing import Any, Dict, List
-
-from django.core.management import get_commands, load_command_class
-
-from .base import DataSection
-
-
-class DocumentationSection(DataSection):
-    """
-    Management commands documentation section.
-
-    Displays the README.md file from django_cfg/management/ directory.
-    """
-
-    template_name = "admin/sections/documentation_section.html"
-    title = "Commands Documentation"
-    icon = "description"
-
-    def get_context_data(self, **kwargs) -> Dict[str, Any]:
-        """Add documentation data directly to context (not nested under 'data')."""
-        # Call parent but skip DataSection's get_data() nesting
-        context = super(DataSection, self).get_context_data(**kwargs)
-        # Add our data directly to context
-        context.update(self.get_data())
-        return context
-
-    def find_module_readme(self, module_name: str) -> str:
-        """Find and read README.md from module's management directory."""
-        import logging
-        logger = logging.getLogger(__name__)
-
-        try:
-            import django_cfg
-            django_cfg_path = Path(django_cfg.__file__).parent
-
-            # Try different paths
-            possible_paths = [
-                django_cfg_path / 'modules' / module_name / 'management' / 'README.md',
-                django_cfg_path / 'management' / 'commands' / module_name / 'README.md',
-            ]
-
-            for readme_path in possible_paths:
-                if readme_path.exists():
-                    logger.info(f"Found module README at: {readme_path}")
-                    with open(readme_path, encoding='utf-8') as f:
-                        return f.read()
-        except Exception as e:
-            logger.debug(f"Could not find README for module {module_name}: {e}")
-
-        return ""
-
-    def get_commands_structure(self) -> Dict[str, List[Dict[str, Any]]]:
-        """Get structured command data grouped by app."""
-        import logging
-        logger = logging.getLogger(__name__)
-
-        # Get all management commands
-        commands = get_commands()
-
-        # Filter only django_cfg commands
-        django_cfg_commands = {
-            name: app for name, app in commands.items()
-            if 'django_cfg' in app
-        }
-
-        logger.info(f"Found {len(django_cfg_commands)} django_cfg commands")
-
-        # Group commands by app
-        commands_by_app = {}
-
-        for cmd_name, app_name in sorted(django_cfg_commands.items()):
-            try:
-                # Load the command class
-                try:
-                    command = load_command_class(app_name, cmd_name)
-                except (ImportError, ModuleNotFoundError) as e:
-                    logger.debug(f"Skipping command {cmd_name}: module not found - {e}")
-                    continue
-
-                # Use app_name as group key
-                if app_name not in commands_by_app:
-                    # Create display name from app_name
-                    display_name = app_name.replace('django_cfg.modules.', '').replace('django_cfg', 'Django CFG').replace('_', ' ').title()
-
-                    commands_by_app[app_name] = {
-                        'name': app_name,
-                        'display_name': display_name,
-                        'commands': []
-                    }
-
-                # Extract command information
-                command_info = {
-                    'name': cmd_name,
-                    'help': getattr(command, 'help', 'No description available'),
-                    'docstring': inspect.cleandoc(command.__doc__) if command.__doc__ else '',
-                    'web_executable': getattr(command, 'web_executable', None),
-                    'requires_input': getattr(command, 'requires_input', None),
-                    'is_destructive': getattr(command, 'is_destructive', None),
-                    'arguments': []
-                }
-
-                # Get arguments
-                try:
-                    parser = command.create_parser('', cmd_name)
-                    actions = [action for action in parser._actions if action.dest != 'help']
-
-                    for action in actions:
-                        if action.option_strings:
-                            command_info['arguments'].append({
-                                'options': action.option_strings,
-                                'help': action.help or 'No description',
-                                'default': action.default if action.default != '==SUPPRESS==' else None,
-                                'required': getattr(action, 'required', False),
-                            })
-                except Exception as e:
-                    logger.debug(f"Could not extract arguments for {cmd_name}: {e}")
-
-                commands_by_app[app_name]['commands'].append(command_info)
-
-            except Exception as e:
-                logger.error(f"Error loading command {cmd_name}: {e}")
-                continue
-
-        return commands_by_app
-
-    def generate_documentation_from_commands(self) -> str:
-        """Generate markdown documentation from command docstrings and module READMEs."""
-        import logging
-        logger = logging.getLogger(__name__)
-
-        markdown_lines = []
-        markdown_lines.append("# Django-CFG Management Commands\n\n")
-
-        # Check for main README.md
-        try:
-            import django_cfg
-            django_cfg_path = Path(django_cfg.__file__).parent
-            main_readme_path = django_cfg_path / 'management' / 'README.md'
-
-            if main_readme_path.exists():
-                logger.info("Found main management README.md, using it as primary documentation")
-                with open(main_readme_path, encoding='utf-8') as f:
-                    return f.read()  # Use existing README if it exists
-        except Exception as e:
-            logger.debug(f"No main README found, continuing with auto-generation: {e}")
-
-        markdown_lines.append("_Auto-generated documentation from command docstrings and module READMEs._\n\n")
-
-        # Get all management commands
-        commands = get_commands()
-
-        # Filter only django_cfg commands
-        django_cfg_commands = {
-            name: app for name, app in commands.items()
-            if 'django_cfg' in app
-        }
-
-        logger.info(f"Found {len(django_cfg_commands)} django_cfg commands")
-
-        # Group commands by module
-        commands_by_module = {}
-        module_paths = {}  # Store module paths for README lookup
-
-        for cmd_name, app_name in sorted(django_cfg_commands.items()):
-            try:
-                # Load the command class
-                command = load_command_class(app_name, cmd_name)
-
-                # Get module path
-                module_path = command.__module__
-                if 'modules' in module_path:
-                    # Extract module name like 'django_ngrok', 'django_tasks', etc.
-                    parts = module_path.split('.')
-                    if 'modules' in parts:
-                        module_idx = parts.index('modules')
-                        if len(parts) > module_idx + 1:
-                            module_name = parts[module_idx + 1]
-                        else:
-                            module_name = 'core'
-                    else:
-                        module_name = 'core'
-                else:
-                    module_name = 'core'
-
-                if module_name not in commands_by_module:
-                    commands_by_module[module_name] = []
-                    module_paths[module_name] = module_path
-
-                commands_by_module[module_name].append((cmd_name, command))
-
-            except Exception as e:
-                logger.error(f"Error loading command {cmd_name}: {e}")
-                continue
-
-        # Generate documentation for each module
-        for module_name in sorted(commands_by_module.keys()):
-            markdown_lines.append(f"\n## {module_name.replace('_', ' ').title()} Commands\n\n")
-
-            # Check for module-specific README
-            module_readme = self.find_module_readme(module_name)
-            if module_readme:
-                markdown_lines.append(f"_{module_name} module documentation:_\n\n")
-                markdown_lines.append(module_readme)
-                markdown_lines.append("\n\n### Available Commands\n\n")
-
-            for cmd_name, command_class in sorted(commands_by_module[module_name]):
-                markdown_lines.append(f"\n#### `{cmd_name}`\n\n")
-
-                # Get help text
-                if hasattr(command_class, 'help'):
-                    markdown_lines.append(f"{command_class.help}\n\n")
-
-                # Get class docstring
-                if command_class.__doc__:
-                    doc = inspect.cleandoc(command_class.__doc__)
-                    markdown_lines.append(f"{doc}\n\n")
-
-                # Get metadata
-                metadata = []
-                if hasattr(command_class, 'web_executable'):
-                    metadata.append(f"**Web Executable**: {'Yes' if command_class.web_executable else 'No'}")
-                if hasattr(command_class, 'requires_input'):
-                    metadata.append(f"**Requires Input**: {'Yes' if command_class.requires_input else 'No'}")
-                if hasattr(command_class, 'is_destructive'):
-                    metadata.append(f"**Destructive**: {'Yes' if command_class.is_destructive else 'No'}")
-
-                if metadata:
-                    markdown_lines.append("**Metadata:**\n\n")
-                    for meta in metadata:
-                        markdown_lines.append(f"- {meta}\n")
-                    markdown_lines.append("\n")
-
-                # Get arguments
-                try:
-                    parser = command_class.create_parser('', cmd_name)
-                    actions = [action for action in parser._actions if action.dest != 'help']
-
-                    if actions:
-                        markdown_lines.append("**Arguments:**\n\n")
-                        for action in actions:
-                            if action.option_strings:
-                                opts = ', '.join(f"`{opt}`" for opt in action.option_strings)
-                                help_text = action.help or 'No description'
-                                markdown_lines.append(f"- {opts}: {help_text}\n")
-                        markdown_lines.append("\n")
-                except Exception as e:
-                    logger.debug(f"Could not extract arguments for {cmd_name}: {e}")
-
-                # Add usage example if available in docstring
-                if command_class.__doc__ and '```' in command_class.__doc__:
-                    markdown_lines.append("**Example:**\n\n")
-
-        return ''.join(markdown_lines)
-
-    def get_data(self) -> Dict[str, Any]:
-        """Get structured command documentation data."""
-        import logging
-        logger = logging.getLogger(__name__)
-
-        try:
-            commands_structure = self.get_commands_structure()
-
-            return {
-                'commands_by_module': commands_structure,
-                'total_commands': sum(len(app['commands']) for app in commands_structure.values()),
-                'total_modules': len(commands_structure),
-            }
-        except Exception as e:
-            logger.error(f"Error generating command structure: {e}", exc_info=True)
-            return {
-                'commands_by_module': {},
-                'total_commands': 0,
-                'total_modules': 0,
-                'error': str(e)
-            }
-
-    def get_data_old(self) -> Dict[str, Any]:
-        """DEPRECATED: Get documentation content from README.md or auto-generate from docstrings."""
-        import logging
-        logger = logging.getLogger(__name__)
-
-        # Check if we should use auto-generation
-        use_autogen = os.environ.get('DJANGO_CFG_AUTOGEN_DOCS', 'true').lower() == 'true'
-
-        readme_content = ""
-        documentation_html = ""
-        readme_path = None
-        readme_exists = False
-
-        if use_autogen:
-            # Auto-generate documentation from command docstrings
-            logger.info("Auto-generating documentation from command docstrings")
-            try:
-                readme_content = self.generate_documentation_from_commands()
-
-                # Convert to HTML
-                try:
-                    import markdown
-                    documentation_html = markdown.markdown(
-                        readme_content,
-                        extensions=[
-                            'markdown.extensions.fenced_code',
-                            'markdown.extensions.tables',
-                            'markdown.extensions.toc',
-                            'markdown.extensions.nl2br',
-                            'markdown.extensions.sane_lists',
-                        ]
-                    )
-                    logger.info("Auto-generated documentation rendered successfully")
-                except ImportError:
-                    logger.warning("Markdown library not available, will display as plain text")
-
-                readme_exists = True
-                readme_path = "Auto-generated from docstrings"
-
-            except Exception as e:
-                logger.error(f"Error auto-generating documentation: {e}", exc_info=True)
-                readme_content = f"Error auto-generating documentation: {str(e)}"
-        else:
-            # Use static README.md file
-            # Try multiple path resolution strategies
-            possible_paths = [
-                # Strategy 1: Relative to this file
-                Path(__file__).parent.parent.parent / 'management' / 'README.md',
-                # Strategy 2: Using django_cfg module location
-                Path(__file__).parent.parent.parent / 'management' / 'README.md',
-                # Strategy 3: Absolute path for django_cfg package
-                Path('/Users/markinmatrix/Documents/htdocs/@CARAPIS/encar_parser_new/@projects/django-cfg/projects/django-cfg-dev/src/django_cfg/management/README.md'),
-            ]
-
-            # Find the first existing path
-            for path in possible_paths:
-                if path.exists():
-                    readme_path = path
-                    logger.info(f"Found README.md at: {readme_path}")
-                    break
-
-            # If still not found, try using django_cfg module import
-            if not readme_path or not readme_path.exists():
-                try:
-                    import django_cfg
-                    django_cfg_path = Path(django_cfg.__file__).parent
-                    readme_path = django_cfg_path / 'management' / 'README.md'
-                    logger.info(f"Using django_cfg module path: {readme_path}")
-                except Exception as e:
-                    logger.error(f"Error finding django_cfg module: {e}")
-                    readme_path = possible_paths[0]  # Fallback to first path
-
-            try:
-                if readme_path and readme_path.exists():
-                    logger.info(f"Reading README from: {readme_path}")
-                    with open(readme_path, encoding='utf-8') as f:
-                        readme_content = f.read()
-                    logger.info(f"README content loaded: {len(readme_content)} characters")
-
-                    # Try to convert markdown to HTML
-                    try:
-                        import markdown
-                        documentation_html = markdown.markdown(
-                            readme_content,
-                            extensions=[
-                                'markdown.extensions.fenced_code',
-                                'markdown.extensions.tables',
-                                'markdown.extensions.toc',
-                                'markdown.extensions.nl2br',
-                                'markdown.extensions.sane_lists',
-                            ]
-                        )
-                        logger.info("Markdown rendered successfully")
-                    except ImportError:
-                        logger.warning("Markdown library not available, will display as plain text")
-                        pass
-
-                    readme_exists = True
-                else:
-                    logger.error(f"README.md not found at: {readme_path}")
-                    readme_content = "README.md not found. Searched paths:\n" + "\n".join(str(p) for p in possible_paths)
-
-            except Exception as e:
-                logger.error(f"Error loading documentation: {e}", exc_info=True)
-                readme_content = f"Error loading documentation: {str(e)}"
-
-        return {
-            'readme_content': readme_content,
-            'documentation_content': documentation_html if documentation_html else None,
-            'readme_path': str(readme_path) if readme_path else 'Not found',
-            'readme_exists': readme_exists,
-        }