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

django_cfg/modules/django_dashboard/sections/widgets.py

@@ -1,222 +0,0 @@
-"""Widgets section for dashboard.
-
-Automatically renders widgets from DashboardManager.get_widgets_config()
-"""
-
-from datetime import timedelta
-from typing import Any, Dict, List
-
-import psutil
-from django.db.models import Avg
-from django.template import Context, Template
-from django.utils import timezone
-
-from .base import DataSection
-
-
-class WidgetsSection(DataSection):
-    """
-    Widgets section showing automatically generated dashboard widgets.
-
-    Widgets are defined in DashboardManager.get_widgets_config() and
-    can include:
-    - System metrics (CPU, Memory, Disk)
-    - RPC monitoring stats
-    - Custom application widgets
-    """
-
-    template_name = "admin/sections/widgets_section.html"
-    title = "Dashboard Widgets"
-    icon = "widgets"
-
-    def get_data(self) -> Dict[str, Any]:
-        """Get widgets configuration from DashboardManager."""
-        from django_cfg.modules.django_unfold.dashboard import get_dashboard_manager
-
-        dashboard_manager = get_dashboard_manager()
-
-        # Get widgets from dashboard manager (base system widgets)
-        widgets = dashboard_manager.get_widgets_config()
-
-        return {
-            'widgets': widgets,
-            'widgets_count': len(widgets),
-            'has_widgets': len(widgets) > 0,
-        }
-
-    def merge_custom_widgets(self, widgets: List[Dict], custom_widgets: List[Any]) -> List[Dict]:
-        """
-        Merge custom widgets from dashboard_callback.
-
-        Allows projects to add widgets via dashboard_callback:
-            context["custom_widgets"] = [
-                StatsCardsWidget(...),
-                ...
-            ]
-        """
-        if not custom_widgets:
-            return widgets
-
-        # Convert custom widgets to dicts if they are Pydantic models
-        for widget in custom_widgets:
-            if hasattr(widget, 'to_dict'):
-                widgets.append(widget.to_dict())
-            elif hasattr(widget, 'model_dump'):
-                widgets.append(widget.model_dump())
-            elif isinstance(widget, dict):
-                widgets.append(widget)
-
-        return widgets
-
-    def get_context_data(self, **kwargs) -> Dict[str, Any]:
-        """Add additional context for widget rendering."""
-        context = super().get_context_data(**kwargs)
-
-        # Get base widgets from DashboardManager
-        widgets = context['data']['widgets']
-
-        # Merge custom widgets from dashboard_callback if provided
-        custom_widgets_from_callback = kwargs.get('custom_widgets', [])
-        if custom_widgets_from_callback:
-            widgets = self.merge_custom_widgets(widgets, custom_widgets_from_callback)
-            # Update count
-            context['data']['widgets_count'] = len(widgets)
-            context['data']['has_widgets'] = len(widgets) > 0
-
-        # Get metrics data first
-        metrics_data = {}
-        metrics_data.update(self.get_system_metrics())
-
-        # Add Centrifugo metrics if enabled
-        dashboard_manager = self._get_dashboard_manager()
-        if dashboard_manager.is_centrifugo_enabled():
-            metrics_data.update(self.get_centrifugo_metrics())
-
-        # Also merge any custom metrics from kwargs
-        custom_metrics = kwargs.get('custom_metrics', {})
-        if custom_metrics:
-            metrics_data.update(custom_metrics)
-
-        # Process widgets and resolve template variables
-        processed_stats_widgets = []
-        for widget in widgets:
-            if widget.get('type') == 'stats_cards':
-                processed_widget = self._process_stats_widget(widget, metrics_data)
-                processed_stats_widgets.append(processed_widget)
-
-        chart_widgets = [w for w in widgets if w.get('type') == 'chart']
-        custom_widgets = [w for w in widgets if w.get('type') not in ['stats_cards', 'chart']]
-
-        # Add processed widgets
-        context.update({
-            'stats_widgets': processed_stats_widgets,
-            'chart_widgets': chart_widgets,
-            'custom_widgets': custom_widgets,
-        })
-
-        # Also add metrics for direct access
-        context.update(metrics_data)
-
-        return context
-
-    def _get_dashboard_manager(self):
-        """Get dashboard manager instance (lazy import to avoid circular dependencies)."""
-        from django_cfg.modules.django_unfold.dashboard import get_dashboard_manager
-        return get_dashboard_manager()
-
-    def _process_stats_widget(self, widget: Dict[str, Any], context_data: Dict[str, Any]) -> Dict[str, Any]:
-        """Process StatsCardsWidget and resolve template variables in cards."""
-        processed_widget = widget.copy()
-        processed_cards = []
-
-        for card in widget.get('cards', []):
-            processed_card = card.copy()
-
-            # Resolve value_template using Django template engine
-            value_template = card.get('value_template', '')
-            if '{{' in value_template:
-                try:
-                    template = Template(value_template)
-                    context = Context(context_data)
-                    resolved_value = template.render(context)
-                    processed_card['value_template'] = resolved_value
-                except Exception:
-                    # Keep original if rendering fails
-                    pass
-
-            # Also resolve change field if it has template variables
-            change_template = card.get('change', '')
-            if change_template and '{{' in change_template:
-                try:
-                    template = Template(change_template)
-                    context = Context(context_data)
-                    resolved_change = template.render(context)
-                    processed_card['change'] = resolved_change
-                except Exception:
-                    # Keep original if rendering fails
-                    pass
-
-            processed_cards.append(processed_card)
-
-        processed_widget['cards'] = processed_cards
-        return processed_widget
-
-    def get_system_metrics(self) -> Dict[str, Any]:
-        """Get system metrics for widgets."""
-        return {
-            'cpu_percent': round(psutil.cpu_percent(interval=0.1), 1),
-            'memory_percent': round(psutil.virtual_memory().percent, 1),
-            'disk_percent': round(psutil.disk_usage('/').percent, 1),
-        }
-
-    def get_centrifugo_metrics(self) -> Dict[str, Any]:
-        """Get Centrifugo metrics for widgets."""
-        try:
-            from django_cfg.apps.centrifugo.models import CentrifugoLog
-
-            # Get stats for last 24 hours
-            since = timezone.now() - timedelta(hours=24)
-
-            logs = CentrifugoLog.objects.filter(created_at__gte=since)
-
-            total_publishes = logs.count()
-            successful_publishes = logs.filter(status='success').count()
-            failed_publishes = logs.filter(status='failed').count()
-            timeout_publishes = logs.filter(status='timeout').count()
-
-            success_rate = round((successful_publishes / total_publishes * 100) if total_publishes > 0 else 0, 1)
-
-            avg_duration = logs.filter(
-                duration_ms__isnull=False
-            ).aggregate(
-                avg=Avg('duration_ms')
-            )['avg']
-
-            avg_duration = round(avg_duration, 1) if avg_duration else 0  # Already in ms
-
-            avg_acks = logs.filter(
-                acks_received__isnull=False
-            ).aggregate(
-                avg=Avg('acks_received')
-            )['avg']
-
-            avg_acks = round(avg_acks, 1) if avg_acks else 0
-
-            return {
-                'centrifugo_total_publishes': total_publishes,
-                'centrifugo_success_rate': success_rate,
-                'centrifugo_avg_duration': avg_duration,
-                'centrifugo_failed_publishes': failed_publishes,
-                'centrifugo_timeout_publishes': timeout_publishes,
-                'centrifugo_avg_acks': avg_acks,
-            }
-        except Exception as e:
-            # Return zeros if Centrifugo models not available
-            return {
-                'centrifugo_total_publishes': 0,
-                'centrifugo_success_rate': 0,
-                'centrifugo_avg_duration': 0,
-                'centrifugo_failed_publishes': 0,
-                'centrifugo_timeout_publishes': 0,
-                'centrifugo_avg_acks': 0,
-            }

django_cfg/modules/django_unfold/callbacks/__init__.py

@@ -1,9 +0,0 @@
-"""
-Django CFG Unfold Callbacks Module
-
-Modular callback system for Django Unfold dashboard.
-"""
-
-from .main import UnfoldCallbacks
-
-__all__ = ['UnfoldCallbacks']

django_cfg/modules/django_unfold/callbacks/actions.py

@@ -1,51 +0,0 @@
-"""
-Quick actions callbacks.
-"""
-
-import logging
-from typing import List
-
-from django_cfg.modules.django_admin.icons import Icons
-
-from ..models.dashboard import QuickAction
-from .base import get_user_admin_urls
-
-logger = logging.getLogger(__name__)
-
-
-class ActionsCallbacks:
-    """Quick actions callbacks."""
-
-    def get_quick_actions(self) -> List[QuickAction]:
-        """Get quick action buttons as Pydantic models."""
-        # Get user admin URLs dynamically based on AUTH_USER_MODEL
-        user_admin_urls = get_user_admin_urls()
-
-        actions = [
-            QuickAction(
-                title="Add User",
-                description="Create new user account",
-                icon=Icons.PERSON_ADD,
-                link=user_admin_urls["add"],
-                color="primary",
-                category="admin",
-            ),
-            QuickAction(
-                title="Support Tickets",
-                description="Manage support tickets",
-                icon=Icons.SUPPORT_AGENT,
-                link="admin:django_cfg_support_ticket_changelist",
-                color="primary",
-                category="support",
-            ),
-            QuickAction(
-                title="Health Check",
-                description="System health status",
-                icon=Icons.HEALTH_AND_SAFETY,
-                link="/cfg/health/",
-                color="success",
-                category="system",
-            ),
-        ]
-
-        return actions

django_cfg/modules/django_unfold/callbacks/apizones.py

@@ -1,122 +0,0 @@
-"""
-Django Client (OpenAPI) integration callbacks.
-"""
-
-import logging
-from typing import Any, Dict, List, Tuple
-
-from django.conf import settings
-
-logger = logging.getLogger(__name__)
-
-
-class OpenAPIClientCallbacks:
-    """Django Client (OpenAPI) integration callbacks."""
-
-    def get_openapi_groups_data(self) -> Tuple[List[Dict[str, Any]], Dict[str, Any]]:
-        """Get Django Client (OpenAPI) groups data."""
-        try:
-            # Get groups from OpenAPI service (includes default cfg group)
-            from django_cfg.modules.django_client.core import get_openapi_service
-
-            service = get_openapi_service()
-            if not service.config:
-                return [], {"total_apps": 0, "total_endpoints": 0, "total_groups": 0}
-
-            # Get groups with defaults (includes cfg group automatically)
-            groups_dict = service.get_groups()
-            groups_list = list(groups_dict.values())
-            api_prefix = getattr(service.config, "api_prefix", "api")
-
-            # Ensure urlconf modules AND URL patterns are created for all groups with apps
-            try:
-                from django.urls import path
-                from drf_spectacular.views import SpectacularAPIView
-                from django_cfg.modules.django_client.core.groups import GroupManager
-                from django_cfg.modules.django_client import urls as client_urls
-
-                manager = GroupManager(service.config)
-                for group in groups_list:
-                    group_name = getattr(group, "name", "unknown") if not isinstance(group, dict) else group.get("name", "unknown")
-                    apps = getattr(group, "apps", []) if not isinstance(group, dict) else group.get("apps", [])
-                    group_version = getattr(group, "version", "1.0.0") if not isinstance(group, dict) else group.get("version", "1.0.0")
-
-                    if apps:
-                        try:
-                            # Create urlconf module
-                            manager.create_urlconf_module(group_name)
-
-                            # Check if URL pattern already exists
-                            url_name = f'openapi-schema-{group_name}'
-                            url_exists = any(
-                                hasattr(pattern, 'name') and pattern.name == url_name
-                                for pattern in client_urls.urlpatterns
-                            )
-
-                            # Add URL pattern if it doesn't exist
-                            if not url_exists:
-                                new_pattern = path(
-                                    f'{group_name}/schema/',
-                                    SpectacularAPIView.as_view(
-                                        urlconf=f'_django_client_urlconf_{group_name}',
-                                        api_version=group_version,
-                                    ),
-                                    name=url_name,
-                                )
-                                client_urls.urlpatterns.append(new_pattern)
-                        except Exception:
-                            pass  # Silently skip if already exists or fails
-            except Exception:
-                pass  # Silently skip if GroupManager fails
-
-            groups_data = []
-            total_apps = 0
-            total_endpoints = 0
-
-            for group in groups_list:
-                # Handle both dict and object access
-                if isinstance(group, dict):
-                    group_name = group.get("name", "unknown")
-                    title = group.get("title", group_name.title())
-                    description = group.get("description", f"{group_name} group")
-                    apps = group.get("apps", [])
-                else:
-                    # Handle object access (for OpenAPIGroupConfig instances)
-                    group_name = getattr(group, "name", "unknown")
-                    title = getattr(group, "title", group_name.title())
-                    description = getattr(group, "description", f"{group_name} group")
-                    apps = getattr(group, "apps", [])
-
-                # Count actual endpoints by checking URL patterns (simplified estimate)
-                endpoint_count = len(apps) * 3  # Conservative estimate
-
-                groups_data.append({
-                    "name": group_name,
-                    "title": title,
-                    "description": description,
-                    "app_count": len(apps),
-                    "endpoint_count": endpoint_count,
-                    "status": "active",
-                    "schema_url": f"/cfg/openapi/{group_name}/schema/",
-                    "api_url": f"/{api_prefix}/{group_name}/",
-                })
-
-                total_apps += len(apps)
-                total_endpoints += endpoint_count
-
-            return groups_data, {
-                "total_apps": total_apps,
-                "total_endpoints": total_endpoints,
-                "total_groups": len(groups_list),
-            }
-        except Exception as e:
-            logger.error(f"Error getting OpenAPI groups: {e}")
-            return [], {
-                "total_apps": 0,
-                "total_endpoints": 0,
-                "total_groups": 0,
-            }
-
-
-# Keep backward compatibility alias
-RevolutionCallbacks = OpenAPIClientCallbacks

django_cfg/modules/django_unfold/callbacks/base.py

@@ -1,290 +0,0 @@
-"""
-Base utilities and helper functions for callbacks.
-"""
-
-import importlib
-import inspect
-import logging
-from typing import Any, Dict, Set
-
-from django.contrib.auth import get_user_model
-from django.core.management import get_commands
-from django.core.management.base import BaseCommand
-
-logger = logging.getLogger(__name__)
-
-
-# Keywords in docstring/code that indicate command should not be in web UI
-DANGEROUS_KEYWORDS: Set[str] = {
-    'questionary', 'input(', 'stdin', 'interactive',  # Requires user input
-    'destructive', 'dangerous', 'irreversible',  # Explicitly marked as dangerous
-    'runserver', 'testserver',  # Dev servers
-}
-
-# Commands that should NEVER appear (absolute blacklist)
-ABSOLUTE_BLACKLIST: Set[str] = {
-    # Destructive database commands
-    'flush', 'sqlflush', 'dbshell',
-
-    # Shell access (security risk)
-    'shell', 'shell_plus',
-
-    # Development server (not for web execution)
-    'runserver', 'testserver', 'runserver_ngrok',
-
-    # Project generation (not applicable in running app)
-    'startapp', 'startproject',
-
-    # SQL commands (direct SQL, potentially dangerous)
-    'sqlmigrate', 'sqlsequencereset',
-}
-
-
-def analyze_command_safety(command_class: BaseCommand, command_name: str) -> Dict[str, Any]:
-    """
-    Analyze command to determine if it's safe for web execution.
-
-    Checks:
-    1. Explicit metadata (web_executable, requires_input, is_destructive)
-    2. Docstring analysis for dangerous keywords
-    3. Source code analysis for interactive input
-    4. Required arguments analysis
-
-    Returns:
-        Dict with safety analysis results
-    """
-    analysis = {
-        'is_safe': True,
-        'reasons': [],
-        'requires_input': False,
-        'is_destructive': False,
-        'web_executable': None,
-    }
-
-    # Check explicit metadata (highest priority)
-    if hasattr(command_class, 'web_executable'):
-        analysis['web_executable'] = command_class.web_executable
-        if not command_class.web_executable:
-            analysis['is_safe'] = False
-            analysis['reasons'].append('Command explicitly marked as not web-executable')
-            return analysis
-
-    if hasattr(command_class, 'requires_input'):
-        analysis['requires_input'] = command_class.requires_input
-        if command_class.requires_input:
-            analysis['is_safe'] = False
-            analysis['reasons'].append('Command requires interactive input')
-            return analysis
-
-    if hasattr(command_class, 'is_destructive'):
-        analysis['is_destructive'] = command_class.is_destructive
-        if command_class.is_destructive:
-            analysis['is_safe'] = False
-            analysis['reasons'].append('Command is marked as destructive')
-            return analysis
-
-    # Analyze docstring for dangerous keywords
-    docstring = (inspect.getdoc(command_class) or '').lower()
-    for keyword in DANGEROUS_KEYWORDS:
-        if keyword in docstring:
-            analysis['is_safe'] = False
-            analysis['reasons'].append(f'Docstring contains dangerous keyword: {keyword}')
-            return analysis
-
-    # Analyze source code for interactive input
-    try:
-        source = inspect.getsource(command_class)
-        if 'questionary' in source or 'input(' in source:
-            analysis['is_safe'] = False
-            analysis['requires_input'] = True
-            analysis['reasons'].append('Command requires interactive user input')
-            return analysis
-    except Exception:
-        # Can't analyze source, be safe
-        pass
-
-    return analysis
-
-
-def is_command_allowed(command_name: str, app_name: str) -> bool:
-    """
-    Check if command should be displayed in web interface.
-
-    Priority:
-    1. Custom blacklist from settings (DJANGO_CFG_COMMANDS_BLACKLIST)
-    2. Absolute blacklist - always exclude
-    3. Custom whitelist from settings (DJANGO_CFG_COMMANDS_WHITELIST)
-    4. Command metadata analysis (web_executable, requires_input, etc.)
-    5. django_cfg apps - analyze each command
-    6. Django core - be selective (only safe utility commands)
-    7. Third party - only if explicitly whitelisted
-
-    You can customize filtering in settings.py:
-
-        DJANGO_CFG_COMMANDS_BLACKLIST = {'my_dangerous_command'}
-        DJANGO_CFG_COMMANDS_WHITELIST = {'my_safe_command'}
-
-    Or add metadata to your Command class:
-
-        class Command(BaseCommand):
-            web_executable = True  # Allow in web UI
-            requires_input = False  # Doesn't need interactive input
-            is_destructive = False  # Not destructive
-    """
-    from django.conf import settings
-
-    # Custom blacklist from settings (highest priority)
-    custom_blacklist = getattr(settings, 'DJANGO_CFG_COMMANDS_BLACKLIST', set())
-    if command_name in custom_blacklist:
-        return False
-
-    # Absolute blacklist
-    if command_name in ABSOLUTE_BLACKLIST:
-        return False
-
-    # Custom whitelist from settings
-    custom_whitelist = getattr(settings, 'DJANGO_CFG_COMMANDS_WHITELIST', set())
-    if command_name in custom_whitelist:
-        return True
-
-    # Load and analyze command
-    try:
-        # Determine module path
-        if app_name == 'django_cfg':
-            module_path = f'django_cfg.management.commands.{command_name}'
-        elif app_name.startswith('django.'):
-            module_path = f'{app_name}.management.commands.{command_name}'
-        else:
-            module_path = f'{app_name}.management.commands.{command_name}'
-
-        command_module = importlib.import_module(module_path)
-        if hasattr(command_module, 'Command'):
-            command_class = command_module.Command
-
-            # Analyze command safety
-            analysis = analyze_command_safety(command_class, command_name)
-
-            # If command has explicit web_executable metadata, use it
-            if analysis['web_executable'] is not None:
-                return analysis['web_executable']
-
-            # If analysis says it's unsafe, exclude
-            if not analysis['is_safe']:
-                logger.debug(f"Command {command_name} excluded: {', '.join(analysis['reasons'])}")
-                return False
-    except Exception as e:
-        # Can't load/analyze command
-        logger.debug(f"Could not analyze command {command_name}: {e}")
-        # Be conservative - if we can't analyze, exclude unless from trusted source
-        pass
-
-    # Django CFG commands - include if analysis passed
-    if app_name == 'django_cfg':
-        return True
-
-    # Safe Django core commands (utility/read-only)
-    safe_django_core = {
-        'check', 'diffsettings', 'showmigrations',
-        'createcachetable', 'sendtestemail',
-    }
-    if app_name.startswith('django.') and command_name in safe_django_core:
-        return True
-
-    # Exclude other Django core by default
-    if app_name.startswith('django.'):
-        return False
-
-    # Third-party apps - only whitelisted
-    return False
-
-
-def get_available_commands():
-    """Get all available Django management commands (filtered for safety)."""
-    commands_dict = get_commands()
-    commands_list = []
-
-    for command_name, app_name in commands_dict.items():
-        # Filter out unsafe/unwanted commands
-        if not is_command_allowed(command_name, app_name):
-            continue
-
-        try:
-            # Try to get command description
-            if app_name == 'django_cfg':
-                module_path = f'django_cfg.management.commands.{command_name}'
-            else:
-                module_path = f'{app_name}.management.commands.{command_name}'
-
-            try:
-                command_module = importlib.import_module(module_path)
-                if hasattr(command_module, 'Command'):
-                    command_class = command_module.Command
-                    description = getattr(command_class, 'help', f'{command_name} command')
-                else:
-                    description = f'{command_name} command'
-            except ImportError:
-                description = f'{command_name} command'
-
-            commands_list.append({
-                'name': command_name,
-                'app': app_name,
-                'description': description,
-                'is_core': app_name.startswith('django.'),
-                'is_custom': app_name == 'django_cfg',
-            })
-        except Exception as e:
-            # Skip problematic commands
-            logger.debug(f"Skipping command {command_name}: {e}")
-            continue
-
-    return commands_list
-
-
-def get_commands_by_category():
-    """Get commands categorized by type."""
-    commands = get_available_commands()
-
-    categorized = {
-        'django_cfg': [],
-        'django_core': [],
-        'third_party': [],
-        'project': [],
-    }
-
-    for cmd in commands:
-        if cmd['app'] == 'django_cfg':
-            categorized['django_cfg'].append(cmd)
-        elif cmd['app'].startswith('django.'):
-            categorized['django_core'].append(cmd)
-        elif cmd['app'].startswith(('src.', 'api.', 'accounts.')):
-            categorized['project'].append(cmd)
-        else:
-            categorized['third_party'].append(cmd)
-
-    return categorized
-
-
-def get_user_admin_urls():
-    """Get admin URLs for user model."""
-    try:
-        User = get_user_model()
-
-        app_label = User._meta.app_label
-        model_name = User._meta.model_name
-
-        return {
-            'changelist': f'admin:{app_label}_{model_name}_changelist',
-            'add': f'admin:{app_label}_{model_name}_add',
-            'change': f'admin:{app_label}_{model_name}_change/{{id}}/',
-            'delete': f'admin:{app_label}_{model_name}_delete/{{id}}/',
-            'view': f'admin:{app_label}_{model_name}_view/{{id}}/',
-        }
-    except Exception:
-        # Universal fallback - return admin index for all actions
-        return {
-            'changelist': 'admin:index',
-            'add': 'admin:index',
-            'change': 'admin:index',
-            'delete': 'admin:index',
-            'view': 'admin:index',
-        }