django-cfg 1.4.48__py3-none-any.whl → 1.5.7__py3-none-any.whl

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',
-        }

django_cfg/modules/django_unfold/callbacks/charts.py

@@ -1,223 +0,0 @@
-"""
-Charts data callbacks.
-"""
-
-import logging
-from datetime import timedelta
-from typing import Any, Dict, List
-
-from django.contrib.auth import get_user_model
-from django.db.models import Count
-from django.utils import timezone
-
-from ..models.dashboard import ChartData, ChartDataset
-
-logger = logging.getLogger(__name__)
-
-
-class ChartsCallbacks:
-    """Charts data callbacks."""
-
-    def _get_user_model(self):
-        """Get the user model safely."""
-        return get_user_model()
-
-    def _get_empty_chart_data(self, label: str) -> Dict[str, Any]:
-        """Get empty chart data structure."""
-        return ChartData(
-            labels=["No Data"],
-            datasets=[
-                ChartDataset(
-                    label=label,
-                    data=[0],
-                    backgroundColor="rgba(156, 163, 175, 0.1)",
-                    borderColor="rgb(156, 163, 175)",
-                    tension=0.4
-                )
-            ]
-        ).model_dump()
-
-    def get_user_registration_chart_data(self) -> Dict[str, Any]:
-        """Get user registration chart data."""
-        try:
-            # Avoid database access during app initialization
-            from django.apps import apps
-            if not apps.ready:
-                return self._get_empty_chart_data("New Users")
-
-            User = self._get_user_model()
-
-            # Get last 7 days of registration data
-            end_date = timezone.now().date()
-            start_date = end_date - timedelta(days=6)
-
-            # Generate date range
-            date_range = []
-            current_date = start_date
-            while current_date <= end_date:
-                date_range.append(current_date)
-                current_date += timedelta(days=1)
-
-            # Get registration counts by date
-            registration_data = (
-                User.objects.filter(date_joined__date__gte=start_date)
-                .extra({'date': "date(date_joined)"})
-                .values('date')
-                .annotate(count=Count('id'))
-                .order_by('date')
-            )
-
-            # Create data dictionary for easy lookup
-            data_dict = {item['date']: item['count'] for item in registration_data}
-
-            # Build chart data
-            labels = [date.strftime("%m/%d") for date in date_range]
-            data_points = [data_dict.get(date, 0) for date in date_range]
-
-            chart_data = ChartData(
-                labels=labels,
-                datasets=[
-                    ChartDataset(
-                        label="New Users",
-                        data=data_points,
-                        backgroundColor="rgba(59, 130, 246, 0.1)",
-                        borderColor="rgb(59, 130, 246)",
-                        tension=0.4
-                    )
-                ]
-            )
-
-            return chart_data.model_dump()
-
-        except Exception as e:
-            logger.error(f"Error getting user registration chart data: {e}")
-            return self._get_empty_chart_data("New Users")
-
-    def get_user_activity_chart_data(self) -> Dict[str, Any]:
-        """Get user activity chart data."""
-        try:
-            # Avoid database access during app initialization
-            from django.apps import apps
-            if not apps.ready:
-                return self._get_empty_chart_data("Active Users")
-
-            User = self._get_user_model()
-
-            # Get activity data for last 7 days
-            end_date = timezone.now().date()
-            start_date = end_date - timedelta(days=6)
-
-            # Generate date range
-            date_range = []
-            current_date = start_date
-            while current_date <= end_date:
-                date_range.append(current_date)
-                current_date += timedelta(days=1)
-
-            # Get login activity (users who logged in each day)
-            activity_data = (
-                User.objects.filter(last_login__date__gte=start_date, last_login__isnull=False)
-                .extra({'date': "date(last_login)"})
-                .values('date')
-                .annotate(count=Count('id'))
-                .order_by('date')
-            )
-
-            # Create data dictionary for easy lookup
-            data_dict = {item['date']: item['count'] for item in activity_data}
-
-            # Build chart data
-            labels = [date.strftime("%m/%d") for date in date_range]
-            data_points = [data_dict.get(date, 0) for date in date_range]
-
-            chart_data = ChartData(
-                labels=labels,
-                datasets=[
-                    ChartDataset(
-                        label="Active Users",
-                        data=data_points,
-                        backgroundColor="rgba(34, 197, 94, 0.1)",
-                        borderColor="rgb(34, 197, 94)",
-                        tension=0.4
-                    )
-                ]
-            )
-
-            return chart_data.model_dump()
-
-        except Exception as e:
-            logger.error(f"Error getting user activity chart data: {e}")
-            return self._get_empty_chart_data("Active Users")
-
-    def get_activity_tracker_data(self) -> List[Dict[str, str]]:
-        """Get activity tracker data for the last 52 weeks (GitHub-style)."""
-        try:
-            # Avoid database access during app initialization
-            from django.apps import apps
-            if not apps.ready:
-                return self._get_empty_tracker_data()
-
-            User = self._get_user_model()
-
-            # Get data for last 52 weeks (365 days)
-            end_date = timezone.now().date()
-            start_date = end_date - timedelta(days=364)  # 52 weeks * 7 days - 1
-
-            # Get activity data by date
-            activity_data = (
-                User.objects.filter(last_login__date__gte=start_date, last_login__isnull=False)
-                .extra({'date': "date(last_login)"})
-                .values('date')
-                .annotate(count=Count('id'))
-                .order_by('date')
-            )
-
-            # Create data dictionary for easy lookup
-            data_dict = {item['date']: item['count'] for item in activity_data}
-
-            # Generate tracker data for each day
-            tracker_data = []
-            current_date = start_date
-
-            while current_date <= end_date:
-                activity_count = data_dict.get(current_date, 0)
-
-                # Determine color based on activity level
-                if activity_count == 0:
-                    color = "bg-base-200 dark:bg-base-700"
-                    level = "No activity"
-                elif activity_count <= 2:
-                    color = "bg-green-200 dark:bg-green-800"
-                    level = "Low activity"
-                elif activity_count <= 5:
-                    color = "bg-green-400 dark:bg-green-600"
-                    level = "Medium activity"
-                elif activity_count <= 10:
-                    color = "bg-green-600 dark:bg-green-500"
-                    level = "High activity"
-                else:
-                    color = "bg-green-800 dark:bg-green-400"
-                    level = "Very high activity"
-
-                tracker_data.append({
-                    "color": color,
-                    "tooltip": f"{current_date.strftime('%Y-%m-%d')}: {activity_count} active users ({level})"
-                })
-
-                current_date += timedelta(days=1)
-
-            return tracker_data
-
-        except Exception as e:
-            logger.error(f"Error getting activity tracker data: {e}")
-            return self._get_empty_tracker_data()
-
-    def _get_empty_tracker_data(self) -> List[Dict[str, str]]:
-        """Get empty tracker data (365 days of no activity)."""
-        tracker_data = []
-        for i in range(365):
-            tracker_data.append({
-                "color": "bg-base-200 dark:bg-base-700",
-                "tooltip": f"Day {i + 1}: No data available"
-            })
-        return tracker_data

django_cfg/modules/django_unfold/callbacks/commands.py

@@ -1,40 +0,0 @@
-"""
-Django commands callbacks.
-"""
-
-import logging
-from typing import Any, Dict
-
-from .base import get_available_commands, get_commands_by_category
-
-logger = logging.getLogger(__name__)
-
-
-class CommandsCallbacks:
-    """Django commands callbacks."""
-
-    def get_django_commands(self) -> Dict[str, Any]:
-        """Get Django management commands information."""
-        try:
-            commands = get_available_commands()
-            categorized = get_commands_by_category()
-
-            return {
-                "commands": commands,
-                "categorized": categorized,
-                "total_commands": len(commands),
-                "categories": list(categorized.keys()),
-                "core_commands": len([cmd for cmd in commands if cmd['is_core']]),
-                "custom_commands": len([cmd for cmd in commands if cmd['is_custom']]),
-            }
-        except Exception as e:
-            logger.error(f"Error getting Django commands: {e}")
-            # Return safe fallback to prevent dashboard from breaking
-            return {
-                "commands": [],
-                "categorized": {},
-                "total_commands": 0,
-                "categories": [],
-                "core_commands": 0,
-                "custom_commands": 0,
-            }