django-cfg 1.4.116__py3-none-any.whl → 1.5.14__py3-none-any.whl

django_cfg/__init__.py

@@ -32,9 +32,14 @@ Example:
 default_app_config = "django_cfg.apps.DjangoCfgConfig"
 
 # Version information
-__version__ = "1.4.116"
+__version__ = "1.5.14"
 __license__ = "MIT"
 
+# Setup warnings debug early (checks env var only at this point)
+# Will also check config.debug_warnings later when config is loaded
+from .core.debug import setup_warnings_debug
+setup_warnings_debug()
+
 # Import registry for organized lazy loading
 from .config import LIB_NAME
 from .registry import DJANGO_CFG_REGISTRY

django_cfg/apps/api/commands/serializers.py

@@ -0,0 +1,152 @@
+"""
+Django CFG Commands API Serializers.
+"""
+
+from rest_framework import serializers
+
+
+class CommandMetadataSerializer(serializers.Serializer):
+    """
+    Serializer for command metadata.
+
+    Includes security attributes from our base classes:
+    - web_executable: Can be executed via web interface
+    - requires_input: Requires interactive user input
+    - is_destructive: Modifies or deletes data
+    - is_allowed: Passes security checks
+    - risk_level: Security risk assessment
+    """
+
+    web_executable = serializers.BooleanField(
+        allow_null=True,
+        help_text="Whether command can be executed via web interface"
+    )
+    requires_input = serializers.BooleanField(
+        allow_null=True,
+        help_text="Whether command requires interactive user input"
+    )
+    is_destructive = serializers.BooleanField(
+        allow_null=True,
+        help_text="Whether command modifies or deletes data"
+    )
+    is_allowed = serializers.BooleanField(
+        help_text="Whether command passes security checks for web execution"
+    )
+    risk_level = serializers.ChoiceField(
+        choices=['safe', 'caution', 'dangerous', 'unknown'],
+        help_text="Security risk level assessment"
+    )
+
+
+class CommandSerializer(serializers.Serializer):
+    """
+    Serializer for Django management commands.
+
+    Returns command information including:
+    - Basic info (name, app, description)
+    - Security metadata (web_executable, requires_input, is_destructive)
+    - Execution status (is_allowed, risk_level)
+    """
+
+    name = serializers.CharField(
+        help_text="Command name"
+    )
+    app = serializers.CharField(
+        help_text="Django app that provides this command"
+    )
+    description = serializers.CharField(
+        help_text="Short description of what the command does"
+    )
+
+    # Security metadata - flattened for easier API consumption
+    web_executable = serializers.BooleanField(
+        allow_null=True,
+        help_text="Can be executed via web interface"
+    )
+    requires_input = serializers.BooleanField(
+        allow_null=True,
+        help_text="Requires interactive user input"
+    )
+    is_destructive = serializers.BooleanField(
+        allow_null=True,
+        help_text="Modifies or deletes data"
+    )
+    is_allowed = serializers.BooleanField(
+        help_text="Passes security checks"
+    )
+    risk_level = serializers.ChoiceField(
+        choices=['safe', 'caution', 'dangerous', 'unknown'],
+        help_text="Security risk level"
+    )
+
+
+class CommandListResponseSerializer(serializers.Serializer):
+    """
+    Serializer for list commands API response.
+
+    Returns categorized commands:
+    - django_cfg: Custom django-cfg commands
+    - django_core: Django built-in commands
+    - third_party: Third-party app commands
+    - project: Project-specific commands
+    """
+
+    status = serializers.ChoiceField(
+        choices=['success', 'error'],
+        help_text="Response status"
+    )
+    commands = serializers.DictField(
+        child=serializers.ListField(child=CommandSerializer()),
+        help_text="Categorized command lists"
+    )
+    total_commands = serializers.IntegerField(
+        help_text="Total number of commands available"
+    )
+    timestamp = serializers.DateTimeField(
+        help_text="Response timestamp"
+    )
+
+
+class CommandExecutionRequestSerializer(serializers.Serializer):
+    """
+    Serializer for command execution requests.
+    """
+
+    command = serializers.CharField(
+        required=True,
+        help_text="Name of the command to execute"
+    )
+    args = serializers.ListField(
+        child=serializers.CharField(),
+        required=False,
+        default=list,
+        help_text="Positional arguments for the command"
+    )
+    options = serializers.DictField(
+        required=False,
+        default=dict,
+        help_text="Named options for the command (e.g., {'--verbose': True})"
+    )
+
+
+class CommandHelpResponseSerializer(serializers.Serializer):
+    """
+    Serializer for command help API response.
+    """
+
+    status = serializers.ChoiceField(
+        choices=['success', 'error'],
+        help_text="Response status"
+    )
+    command = serializers.CharField(
+        help_text="Command name"
+    )
+    app = serializers.CharField(
+        help_text="Django app"
+    )
+    help = serializers.CharField(
+        help_text="Full help text from command --help"
+    )
+    timestamp = serializers.DateTimeField(
+        help_text="Response timestamp"
+    )

django_cfg/apps/api/commands/views.py

@@ -49,6 +49,7 @@ def list_commands_view(request):
                 "name": command_name,
                 "app": app_name,
                 "description": _get_command_description(command_name),
+                **_get_command_metadata(command_name, app_name),
             }
 
             if app_name == "django_cfg":
@@ -270,6 +271,37 @@ def _get_command_description(command_name: str) -> str:
         return f'Django management command: {command_name}'
 
 
+def _get_command_metadata(command_name: str, app_name: str) -> dict:
+    """
+    Get security metadata for a command.
+
+    Returns:
+        Dict with web_executable, requires_input, is_destructive, is_allowed
+    """
+    try:
+        from django.core.management import load_command_class
+        from django_cfg.apps.system.dashboard.services.commands_security import is_command_allowed, get_command_risk_level
+
+        command_instance = load_command_class(app_name, command_name)
+
+        return {
+            'web_executable': getattr(command_instance, 'web_executable', None),
+            'requires_input': getattr(command_instance, 'requires_input', None),
+            'is_destructive': getattr(command_instance, 'is_destructive', None),
+            'is_allowed': is_command_allowed(command_name, app_name),
+            'risk_level': get_command_risk_level(command_name, app_name),
+        }
+    except Exception as e:
+        logger.debug(f"Could not load metadata for {command_name}: {e}")
+        return {
+            'web_executable': None,
+            'requires_input': None,
+            'is_destructive': None,
+            'is_allowed': False,
+            'risk_level': 'unknown',
+        }
+
+
 def _get_command_help(command_name: str) -> str:
     """Get full help text for a command."""
     try:

django_cfg/apps/{accounts → business/accounts}/admin/inlines.py

@@ -80,7 +80,7 @@ class UserEmailLogInline(TabularInline):
 
             # Only import if newsletter is enabled
             if base_module.is_newsletter_enabled():
-                from django_cfg.apps.newsletter.models import EmailLog
+                from django_cfg.apps.business.newsletter.models import EmailLog
                 self.model = EmailLog
         except (ImportError, Exception):
             # Newsletter app not available or not enabled
@@ -134,7 +134,7 @@ class UserSupportTicketsInline(TabularInline):
 
             # Only import if support is enabled
             if base_module.is_support_enabled():
-                from django_cfg.apps.support.models import Ticket
+                from django_cfg.apps.business.support.models import Ticket
                 self.model = Ticket
         except (ImportError, Exception):
             # Support app not available or not enabled

django_cfg/apps/{accounts → business/accounts}/admin/user_admin.py

@@ -270,7 +270,7 @@ class CustomUserAdmin(BaseUserAdmin, PydanticAdmin):
             if not base_module.is_newsletter_enabled():
                 return None
 
-            from django_cfg.apps.newsletter.models import EmailLog
+            from django_cfg.apps.business.newsletter.models import EmailLog
             count = EmailLog.objects.filter(user=obj).count()
             if count == 0:
                 return None
@@ -297,7 +297,7 @@ class CustomUserAdmin(BaseUserAdmin, PydanticAdmin):
             if not base_module.is_support_enabled():
                 return None
 
-            from django_cfg.apps.support.models import Ticket
+            from django_cfg.apps.business.support.models import Ticket
             count = Ticket.objects.filter(user=obj).count()
             if count == 0:
                 return None

django_cfg/apps/{accounts → business/accounts}/apps.py

@@ -9,11 +9,11 @@ class AccountsConfig(AppConfig):
     """Accounts application configuration."""
 
     default_auto_field = "django.db.models.BigAutoField"
-    name = "django_cfg.apps.accounts"
+    name = "django_cfg.apps.business.accounts"
     label = "django_cfg_accounts"
     verbose_name = "Django CFG Accounts"
 
     def ready(self):
         """Initialize the accounts application."""
         # Import signal handlers
-        import django_cfg.apps.accounts.signals  # noqa
+        import django_cfg.apps.business.accounts.signals  # noqa

django_cfg/apps/{accounts → business/accounts}/management/commands/otp_test.py

@@ -2,17 +2,20 @@
 Management command to test OTP functionality.
 """
 
-from django.core.management.base import BaseCommand, CommandError
+from django.core.management.base import CommandError
 from django.utils import timezone
 from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
 
+from django_cfg.management.utils import SafeCommand
+
 from ...models import OTPSecret
 from ...services.otp_service import OTPService
 
 
-class Command(BaseCommand):
+class Command(SafeCommand):
+    command_name = 'otp_test'
     help = "Test OTP functionality with email and telegram delivery"
 
     def __init__(self, *args, **kwargs):

django_cfg/apps/{accounts → business/accounts}/managers/user_manager.py

@@ -111,7 +111,7 @@ class UserManager(UserManager):
             is_new_user: Whether this is a new user registration
         """
         try:
-            from django_cfg.apps.accounts.models import RegistrationSource, UserRegistrationSource
+            from django_cfg.apps.business.accounts.models import RegistrationSource, UserRegistrationSource
 
             # Get or create source
             source, source_created = RegistrationSource.objects.get_or_create(
@@ -235,7 +235,7 @@ class UserManager(UserManager):
             return 0
 
         try:
-            from django_cfg.apps.support.models import Ticket
+            from django_cfg.apps.business.support.models import Ticket
             count = Ticket.objects.get_unanswered_messages_count(user)
             return count
         except (ImportError, Exception):

django_cfg/apps/{accounts → business/accounts}/migrations/0001_initial.py

@@ -6,8 +6,8 @@ import django.utils.timezone
 from django.conf import settings
 from django.db import migrations, models
 
-import django_cfg.apps.accounts.managers.user_manager
-import django_cfg.apps.accounts.models
+import django_cfg.apps.business.accounts.managers.user_manager
+import django_cfg.apps.business.accounts.models
 
 
 class Migration(migrations.Migration):
@@ -53,7 +53,7 @@ class Migration(migrations.Migration):
                 ('company', models.CharField(blank=True, max_length=100)),
                 ('phone', models.CharField(blank=True, max_length=20)),
                 ('position', models.CharField(blank=True, max_length=100)),
-                ('avatar', models.ImageField(blank=True, null=True, upload_to=django_cfg.apps.accounts.models.user_avatar_path)),
+                ('avatar', models.ImageField(blank=True, null=True, upload_to=django_cfg.apps.business.accounts.models.user_avatar_path)),
                 ('updated_at', models.DateTimeField(auto_now=True)),
                 ('groups', models.ManyToManyField(blank=True, help_text='The groups this user belongs to. A user will get all permissions granted to each of their groups.', related_name='user_set', related_query_name='user', to='auth.group', verbose_name='groups')),
                 ('user_permissions', models.ManyToManyField(blank=True, help_text='Specific permissions for this user.', related_name='user_set', related_query_name='user', to='auth.permission', verbose_name='user permissions')),
@@ -63,7 +63,7 @@ class Migration(migrations.Migration):
                 'verbose_name_plural': 'Users',
             },
             managers=[
-                ('objects', django_cfg.apps.accounts.managers.user_manager.UserManager()),
+                ('objects', django_cfg.apps.business.accounts.managers.user_manager.UserManager()),
             ],
         ),
         migrations.CreateModel(

django_cfg/apps/{agents → business/agents}/__init__.py

@@ -8,7 +8,7 @@ __version__ = "0.1.0"
 __author__ = "Django-CFG Team"
 
 # Set default app config
-default_app_config = 'django_cfg.apps.agents.apps.AgentsConfig'
+default_app_config = 'django_cfg.apps.business.agents.apps.AgentsConfig'
 
 __all__ = [
     # Core classes

django_cfg/apps/{agents → business/agents}/apps.py

@@ -9,7 +9,7 @@ class AgentsConfig(AppConfig):
     """Django app configuration for Django Agents."""
 
     default_auto_field = 'django.db.models.BigAutoField'
-    name = 'django_cfg.apps.agents'
+    name = 'django_cfg.apps.business.agents'
     label = 'django_cfg_agents'
     verbose_name = 'Django Agents'
 

django_cfg/apps/business/agents/management/commands/create_agent.py

@@ -0,0 +1,177 @@
+"""
+Management command to create agent definitions.
+"""
+
+import asyncio
+
+from django.contrib.auth.models import User
+from django.core.management.base import CommandError
+
+from django_cfg.management.utils import AdminCommand
+
+from django_cfg.apps.business.agents.models.registry import AgentDefinition
+
+
+class Command(AdminCommand):
+    """Create agent definition from command line."""
+
+    command_name = 'create_agent'
+    help = 'Create a new agent definition'
+
+    def add_arguments(self, parser):
+        """Add command arguments."""
+        parser.add_argument('name', type=str, help='Agent name (unique identifier)')
+        parser.add_argument('instructions', type=str, help='Agent instructions/system prompt')
+
+        parser.add_argument(
+            '--deps-type',
+            type=str,
+            default='DjangoDeps',
+            help='Dependencies type (default: DjangoDeps)'
+        )
+        parser.add_argument(
+            '--output-type',
+            type=str,
+            default='ProcessResult',
+            help='Output type (default: ProcessResult)'
+        )
+        parser.add_argument(
+            '--model',
+            type=str,
+            default='openai:gpt-4o-mini',
+            help='LLM model to use (default: openai:gpt-4o-mini)'
+        )
+        parser.add_argument(
+            '--category',
+            type=str,
+            default='',
+            help='Agent category'
+        )
+        parser.add_argument(
+            '--timeout',
+            type=int,
+            default=300,
+            help='Execution timeout in seconds (default: 300)'
+        )
+        parser.add_argument(
+            '--max-retries',
+            type=int,
+            default=3,
+            help='Maximum retry attempts (default: 3)'
+        )
+        parser.add_argument(
+            '--public',
+            action='store_true',
+            help='Make agent public (accessible to all users)'
+        )
+        parser.add_argument(
+            '--no-cache',
+            action='store_true',
+            help='Disable caching for this agent'
+        )
+        parser.add_argument(
+            '--creator',
+            type=str,
+            help='Username of agent creator (defaults to first superuser)'
+        )
+        parser.add_argument(
+            '--description',
+            type=str,
+            default='',
+            help='Agent description'
+        )
+        parser.add_argument(
+            '--tags',
+            type=str,
+            nargs='*',
+            help='Agent tags (space-separated)'
+        )
+
+    def handle(self, *args, **options):
+        """Handle command execution."""
+        # Run async operations
+        asyncio.run(self._create_agent(options))
+
+    async def _create_agent(self, options):
+        """Create agent definition."""
+        name = options['name']
+        instructions = options['instructions']
+
+        # Validate name
+        if await AgentDefinition.objects.filter(name=name).aexists():
+            raise CommandError(f"Agent '{name}' already exists")
+
+        # Get creator user
+        creator = await self._get_creator_user(options.get('creator'))
+
+        # Prepare agent data
+        agent_data = {
+            'name': name,
+            'instructions': instructions,
+            'deps_type': options['deps_type'],
+            'output_type': options['output_type'],
+            'model': options['model'],
+            'category': options['category'],
+            'timeout': options['timeout'],
+            'max_retries': options['max_retries'],
+            'is_public': options['public'],
+            'enable_caching': not options['no_cache'],
+            'created_by': creator,
+            'description': options['description'],
+        }
+
+        # Add tags if provided
+        if options['tags']:
+            agent_data['tags'] = options['tags']
+
+        # Create agent definition
+        try:
+            agent_def = await AgentDefinition.objects.acreate(**agent_data)
+
+            self.stdout.write(
+                self.style.SUCCESS(f"✅ Created agent definition: {agent_def.name}")
+            )
+
+            # Show agent details
+            self.stdout.write("\nAgent Details:")
+            self.stdout.write(f"  Name: {agent_def.name}")
+            self.stdout.write(f"  Display Name: {agent_def.display_name}")
+            self.stdout.write(f"  Category: {agent_def.category or 'None'}")
+            self.stdout.write(f"  Model: {agent_def.model}")
+            self.stdout.write(f"  Dependencies: {agent_def.deps_type}")
+            self.stdout.write(f"  Output Type: {agent_def.output_type}")
+            self.stdout.write(f"  Timeout: {agent_def.timeout}s")
+            self.stdout.write(f"  Max Retries: {agent_def.max_retries}")
+            self.stdout.write(f"  Public: {agent_def.is_public}")
+            self.stdout.write(f"  Caching: {agent_def.enable_caching}")
+            self.stdout.write(f"  Created by: {agent_def.created_by.username}")
+
+            if agent_def.tags:
+                self.stdout.write(f"  Tags: {', '.join(agent_def.tags)}")
+
+            if agent_def.description:
+                self.stdout.write(f"  Description: {agent_def.description}")
+
+            # Instructions preview
+            instructions_preview = agent_def.instructions[:200]
+            if len(agent_def.instructions) > 200:
+                instructions_preview += "..."
+
+            self.stdout.write(f"  Instructions: {instructions_preview}")
+
+        except Exception as e:
+            raise CommandError(f"Failed to create agent: {e}")
+
+    async def _get_creator_user(self, username):
+        """Get creator user."""
+        if username:
+            try:
+                return await User.objects.aget(username=username)
+            except User.DoesNotExist:
+                raise CommandError(f"User '{username}' not found")
+        else:
+            # Use first superuser
+            try:
+                return await User.objects.filter(is_superuser=True).afirst()
+            except User.DoesNotExist:
+                raise CommandError("No superuser found. Please create a superuser first or specify --creator")