django-cfg 1.5.8__py3-none-any.whl → 1.5.20__py3-none-any.whl

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

@@ -0,0 +1,205 @@
+"""
+Management command to load pre-built agent templates.
+"""
+
+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):
+    """Load agent definitions from templates."""
+
+    command_name = 'load_agent_templates'
+    help = 'Load pre-built agent templates'
+
+    def add_arguments(self, parser):
+        """Add command arguments."""
+        parser.add_argument(
+            '--list',
+            action='store_true',
+            help='List available templates'
+        )
+        parser.add_argument(
+            '--load',
+            type=str,
+            nargs='*',
+            help='Load specific templates (space-separated names)'
+        )
+        parser.add_argument(
+            '--load-all',
+            action='store_true',
+            help='Load all available templates'
+        )
+        parser.add_argument(
+            '--creator',
+            type=str,
+            help='Username of agent creator (defaults to first superuser)'
+        )
+
+    def handle(self, *args, **options):
+        """Handle command execution."""
+        if options['list']:
+            self._list_templates()
+        elif options['load'] or options['load_all']:
+            asyncio.run(self._load_templates(options))
+        else:
+            self.stdout.write(
+                self.style.ERROR('Please specify --list, --load, or --load-all')
+            )
+
+    def _list_templates(self):
+        """List available templates."""
+        templates = self._get_available_templates()
+
+        self.stdout.write(self.style.SUCCESS('📋 Available Agent Templates:'))
+        self.stdout.write('=' * 40)
+
+        for category, agents in templates.items():
+            self.stdout.write(f"\n{category.upper()}:")
+            for agent_name, agent_info in agents.items():
+                self.stdout.write(f"  • {agent_name}: {agent_info['description']}")
+
+    async def _load_templates(self, options):
+        """Load templates."""
+        creator = await self._get_creator_user(options.get('creator'))
+        templates = self._get_available_templates()
+
+        if options['load_all']:
+            # Load all templates
+            to_load = []
+            for category_templates in templates.values():
+                to_load.extend(category_templates.keys())
+        else:
+            to_load = options['load']
+
+        loaded_count = 0
+
+        for template_name in to_load:
+            # Find template
+            template_info = None
+            for category_templates in templates.values():
+                if template_name in category_templates:
+                    template_info = category_templates[template_name]
+                    break
+
+            if not template_info:
+                self.stdout.write(
+                    self.style.WARNING(f"Template '{template_name}' not found")
+                )
+                continue
+
+            # Check if agent already exists
+            if await AgentDefinition.objects.filter(name=template_name).aexists():
+                self.stdout.write(
+                    self.style.WARNING(f"Agent '{template_name}' already exists, skipping")
+                )
+                continue
+
+            # Create agent
+            try:
+                agent_data = template_info.copy()
+                agent_data['name'] = template_name
+                agent_data['created_by'] = creator
+
+                await AgentDefinition.objects.acreate(**agent_data)
+
+                self.stdout.write(
+                    self.style.SUCCESS(f"✅ Loaded template: {template_name}")
+                )
+                loaded_count += 1
+
+            except Exception as e:
+                self.stdout.write(
+                    self.style.ERROR(f"Failed to load template '{template_name}': {e}")
+                )
+
+        self.stdout.write(
+            self.style.SUCCESS(f"\n🎉 Loaded {loaded_count} agent templates")
+        )
+
+    def _get_available_templates(self):
+        """Get available agent templates."""
+        return {
+            'content': {
+                'content_analyzer': {
+                    'description': 'Analyze content sentiment, topics, and quality',
+                    'instructions': 'Analyze content for sentiment, topics, keywords, and quality metrics.',
+                    'deps_type': 'ContentDeps',
+                    'output_type': 'AnalysisResult',
+                    'category': 'content',
+                    'model': 'openai:gpt-4o-mini',
+                },
+                'content_generator': {
+                    'description': 'Generate high-quality content based on requirements',
+                    'instructions': 'Generate engaging, well-structured content based on type, audience, and style requirements.',
+                    'deps_type': 'ContentDeps',
+                    'output_type': 'ProcessResult',
+                    'category': 'content',
+                    'model': 'openai:gpt-4o-mini',
+                },
+                'content_validator': {
+                    'description': 'Validate content quality and compliance',
+                    'instructions': 'Validate content for grammar, style, accuracy, and guideline compliance.',
+                    'deps_type': 'ContentDeps',
+                    'output_type': 'ValidationResult',
+                    'category': 'content',
+                    'model': 'openai:gpt-4o-mini',
+                },
+            },
+            'data': {
+                'data_processor': {
+                    'description': 'Process and transform data',
+                    'instructions': 'Process, clean, and transform data according to specifications.',
+                    'deps_type': 'DataProcessingDeps',
+                    'output_type': 'ProcessResult',
+                    'category': 'data',
+                    'model': 'openai:gpt-4o-mini',
+                },
+                'data_validator': {
+                    'description': 'Validate data quality and integrity',
+                    'instructions': 'Validate data quality, check for errors, and ensure integrity.',
+                    'deps_type': 'DataProcessingDeps',
+                    'output_type': 'ValidationResult',
+                    'category': 'data',
+                    'model': 'openai:gpt-4o-mini',
+                },
+            },
+            'business': {
+                'business_rules': {
+                    'description': 'Apply business rules and logic',
+                    'instructions': 'Apply business rules, validate decisions, and ensure compliance.',
+                    'deps_type': 'BusinessLogicDeps',
+                    'output_type': 'ProcessResult',
+                    'category': 'business',
+                    'model': 'openai:gpt-4o-mini',
+                },
+                'decision_maker': {
+                    'description': 'Make decisions based on criteria',
+                    'instructions': 'Analyze options and make informed decisions based on criteria and context.',
+                    'deps_type': 'BusinessLogicDeps',
+                    'output_type': 'ProcessResult',
+                    'category': 'business',
+                    'model': 'openai:gpt-4o-mini',
+                },
+            }
+        }
+
+    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")

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

@@ -5,17 +5,19 @@ Management command to show orchestrator status.
 import asyncio
 from datetime import timedelta
 
-from django.core.management.base import BaseCommand
 from django.utils import timezone
 
+from django_cfg.management.utils import SafeCommand
+
 from django_cfg.apps.business.agents.integration.registry import get_registry
 from django_cfg.apps.business.agents.models.execution import AgentExecution, WorkflowExecution
 from django_cfg.apps.business.agents.models.registry import AgentDefinition
 
 
-class Command(BaseCommand):
+class Command(SafeCommand):
     """Show Django Orchestrator status and statistics."""
 
+    command_name = 'orchestrator_status'
     help = 'Display Django Orchestrator status and statistics'
 
     def add_arguments(self, parser):

django_cfg/apps/business/knowbase/management/commands/knowbase_stats.py

@@ -3,17 +3,19 @@ Knowledge Base statistics command.
 """
 
 from django.contrib.auth import get_user_model
-from django.core.management.base import BaseCommand
 from django.db import models
 from django.db.models import Avg, Count, ExpressionWrapper, F, Q, Sum
 from django.db.models.functions import Extract
 
+from django_cfg.management.utils import SafeCommand
+
 User = get_user_model()
 
 
-class Command(BaseCommand):
+class Command(SafeCommand):
     """Display Knowledge Base statistics."""
 
+    command_name = 'knowbase_stats'
     help = 'Display Knowledge Base usage statistics'
 
     def add_arguments(self, parser):

django_cfg/apps/business/knowbase/management/commands/setup_knowbase.py

@@ -2,13 +2,15 @@
 Setup command for Knowledge Base application.
 """
 
-from django.core.management.base import BaseCommand
 from django.db import connection
 
+from django_cfg.management.utils import AdminCommand
 
-class Command(BaseCommand):
+
+class Command(AdminCommand):
     """Setup Knowledge Base with pgvector extension and initial data."""
 
+    command_name = 'setup_knowbase'
     help = 'Setup Knowledge Base with pgvector extension and run migrations'
 
     def add_arguments(self, parser):

django_cfg/apps/business/newsletter/management/commands/test_newsletter.py

@@ -3,7 +3,9 @@ Management command to test newsletter sending functionality.
 """
 
 from django.contrib.auth import get_user_model
-from django.core.management.base import BaseCommand, CommandError
+from django.core.management.base import CommandError
+
+from django_cfg.management.utils import SafeCommand
 
 from django_cfg.apps.business.newsletter.models import Newsletter, NewsletterCampaign, NewsletterSubscription
 from django_cfg.apps.business.newsletter.services.email_service import NewsletterEmailService
@@ -11,7 +13,8 @@ from django_cfg.apps.business.newsletter.services.email_service import Newslette
 User = get_user_model()
 
 
-class Command(BaseCommand):
+class Command(SafeCommand):
+    command_name = 'test_newsletter'
     help = 'Test newsletter sending functionality'
 
     def add_arguments(self, parser):

django_cfg/apps/business/payments/management/commands/check_payment_status.py

@@ -7,11 +7,12 @@ Uses questionary for interactive selection or accepts payment ID as argument.
 from uuid import UUID
 
 import questionary
-from django.core.management.base import BaseCommand
 from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
 
+from django_cfg.management.utils import InteractiveCommand
+
 from django_cfg.apps.business.payments.models import Payment
 from django_cfg.apps.business.payments.services import PaymentService, CheckStatusRequest
 from django_cfg.apps.business.payments.api.views import get_nowpayments_provider
@@ -19,7 +20,8 @@ from django_cfg.apps.business.payments.api.views import get_nowpayments_provider
 console = Console()
 
 
-class Command(BaseCommand):
+class Command(InteractiveCommand):
+    command_name = 'check_payment_status'
     help = 'Check payment status interactively or by payment ID'
 
     def add_arguments(self, parser):

django_cfg/apps/business/payments/management/commands/create_payment.py

@@ -8,11 +8,12 @@ from decimal import Decimal, InvalidOperation
 
 import questionary
 from django.contrib.auth import get_user_model
-from django.core.management.base import BaseCommand
 from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
 
+from django_cfg.management.utils import InteractiveCommand
+
 from django_cfg.apps.business.payments.models import Currency, Payment
 from django_cfg.apps.business.payments.services import PaymentService, CreatePaymentRequest
 from django_cfg.apps.business.payments.api.views import get_nowpayments_provider
@@ -21,7 +22,8 @@ User = get_user_model()
 console = Console()
 
 
-class Command(BaseCommand):
+class Command(InteractiveCommand):
+    command_name = 'create_payment'
     help = 'Create a payment interactively using questionary wizard'
 
     def add_arguments(self, parser):

django_cfg/apps/business/payments/management/commands/sync_currencies.py

@@ -5,19 +5,21 @@ Fetches available currencies from NowPayments and updates local database.
 """
 
 import questionary
-from django.core.management.base import BaseCommand
 from rich.console import Console
 from rich.panel import Panel
 from rich.progress import Progress, SpinnerColumn, TextColumn
 from rich.table import Table
 
+from django_cfg.management.utils import AdminCommand
+
 from django_cfg.apps.business.payments.models import Currency
 from django_cfg.apps.business.payments.api.views import get_nowpayments_provider
 
 console = Console()
 
 
-class Command(BaseCommand):
+class Command(AdminCommand):
+    command_name = 'sync_currencies'
     help = 'Sync currencies from NowPayments provider'
 
     def add_arguments(self, parser):

django_cfg/apps/business/support/serializers.py

@@ -8,13 +8,14 @@ from .models import Message, Ticket
 User = get_user_model()
 
 class SenderSerializer(serializers.ModelSerializer):
-    avatar = serializers.SerializerMethodField()
+    avatar = serializers.SerializerMethodField(allow_null=True)
     initials = serializers.ReadOnlyField()
 
     class Meta:
         model = User
         fields = ['id', 'display_username', 'email', 'avatar', 'initials', 'is_staff', 'is_superuser']
-        read_only_fields = fields
+        # Don't include avatar in read_only_fields to make it optional in OpenAPI schema
+        read_only_fields = ['id', 'display_username', 'email', 'initials', 'is_staff', 'is_superuser']
 
     def get_avatar(self, obj) -> Optional[str]:
         if obj.avatar:

django_cfg/apps/integrations/centrifugo/apps.py

@@ -32,6 +32,7 @@ class CentrifugoConfig(AppConfig):
         Initialize app when Django starts.
 
         Validates that all required Centrifugo dependencies are installed.
+        Registers signal handlers for JWT token customization.
         """
         from django_cfg.modules.django_logging import get_logger
 
@@ -40,7 +41,7 @@ class CentrifugoConfig(AppConfig):
         # Check dependencies if needed (only when using Centrifugo features)
         self._check_dependencies_if_needed()
 
-        logger.info("Centrifugo app initialized")
+        logger.info("Centrifugo app initialized (middleware will inject JWT tokens)")
 
     def _check_dependencies_if_needed(self):
         """

django_cfg/apps/integrations/centrifugo/codegen/generators/typescript_thin/templates/rpc-client.ts.j2

@@ -10,6 +10,7 @@ import { Centrifuge } from 'centrifuge';
 export class CentrifugoRPCClient {
   private centrifuge: Centrifuge;
   private subscription: any;
+  private channelSubscriptions: Map<string, any> = new Map();
   private pendingRequests: Map<string, { resolve: Function; reject: Function }> = new Map();
   private readonly replyChannel: string;
   private readonly timeout: number;
@@ -27,12 +28,7 @@ export class CentrifugoRPCClient {
       token,
     });
 
-    this.centrifuge.on('connected', (ctx) => {
-      console.log('✅ Connected to Centrifugo');
-    });
-
     this.centrifuge.on('disconnected', (ctx) => {
-      console.warn('Disconnected:', ctx);
       // Reject all pending requests
       this.pendingRequests.forEach(({ reject }) => {
         reject(new Error('Disconnected from Centrifugo'));
@@ -43,6 +39,27 @@ export class CentrifugoRPCClient {
 
   async connect(): Promise<void> {
     return new Promise((resolve, reject) => {
+      let resolved = false;
+
+      // Listen to Centrifuge connection events
+      const onConnected = () => {
+        if (!resolved) {
+          resolved = true;
+          resolve();
+        }
+      };
+
+      const onError = (ctx: any) => {
+        if (!resolved) {
+          resolved = true;
+          reject(new Error(ctx.message || 'Connection error'));
+        }
+      };
+
+      this.centrifuge.on('connected', onConnected);
+      this.centrifuge.on('error', onError);
+
+      // Start connection
       this.centrifuge.connect();
 
       // Subscribe to reply channel
@@ -53,11 +70,17 @@ export class CentrifugoRPCClient {
       });
 
       this.subscription.on('subscribed', () => {
-        resolve();
+        // Subscription successful (optional, we already resolved on 'connected')
       });
 
       this.subscription.on('error', (ctx: any) => {
-        reject(new Error(ctx.error?.message || 'Subscription error'));
+        // Error code 105 = "already subscribed" (server-side subscription from JWT)
+        // This is not an error - the channel is already active via server-side subscription
+        if (ctx.error?.code === 105) {
+          // This is fine, server-side subscription exists
+        } else {
+          console.error(`Subscription error for ${this.replyChannel}:`, ctx.error);
+        }
       });
 
       this.subscription.subscribe();
@@ -65,9 +88,14 @@ export class CentrifugoRPCClient {
   }
 
   async disconnect(): Promise<void> {
+    // Unsubscribe from all event channels
+    this.unsubscribeAll();
+
+    // Unsubscribe from RPC reply channel
     if (this.subscription) {
       this.subscription.unsubscribe();
     }
+
     this.centrifuge.disconnect();
   }
 
@@ -103,21 +131,17 @@ export class CentrifugoRPCClient {
     // Publish request
     await this.centrifuge.publish('rpc.requests', message);
 
-    console.log(`📤 RPC call: ${method} (${correlationId})`);
-
     return promise;
   }
 
   private handleResponse(data: any): void {
     const correlationId = data.correlation_id;
     if (!correlationId) {
-      console.warn('Received response without correlation_id');
       return;
     }
 
     const pending = this.pendingRequests.get(correlationId);
     if (!pending) {
-      console.warn(`Received response for unknown correlation_id: ${correlationId}`);
       return;
     }
 
@@ -126,7 +150,6 @@ export class CentrifugoRPCClient {
     if (data.error) {
       pending.reject(new Error(data.error.message || 'RPC error'));
     } else {
-      console.log(`📥 RPC response: ${correlationId}`);
       pending.resolve(data.result);
     }
   }
@@ -134,4 +157,120 @@ export class CentrifugoRPCClient {
   private generateCorrelationId(): string {
     return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
   }
+
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  // Channel Subscription API (for gRPC events)
+  // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  /**
+   * Subscribe to a Centrifugo channel for real-time events.
+   *
+   * @param channel - Channel name (e.g., 'bot#bot-123#heartbeat')
+   * @param callback - Callback for received messages
+   * @returns Unsubscribe function
+   *
+   * @example
+   * const unsubscribe = client.subscribe('bot#bot-123#heartbeat', (data) => {
+   *   console.log('Heartbeat:', data);
+   * });
+   *
+   * // Later: unsubscribe when done
+   * unsubscribe();
+   */
+  subscribe(channel: string, callback: (data: any) => void): () => void {
+    // Check if already subscribed
+    if (this.channelSubscriptions.has(channel)) {
+      return () => {}; // Return no-op unsubscribe
+    }
+
+    // Create new subscription
+    const sub = this.centrifuge.newSubscription(channel);
+
+    // Handle publications
+    sub.on('publication', (ctx: any) => {
+      callback(ctx.data);
+    });
+
+    // Handle subscription lifecycle
+    sub.on('subscribed', () => {
+      // Subscription successful
+    });
+
+    sub.on('error', (ctx: any) => {
+      console.error(`Subscription error for ${channel}:`, ctx.error);
+    });
+
+    // Start subscription
+    sub.subscribe();
+
+    // Store subscription
+    this.channelSubscriptions.set(channel, sub);
+
+    // Return unsubscribe function
+    return () => this.unsubscribe(channel);
+  }
+
+  /**
+   * Unsubscribe from a channel.
+   *
+   * @param channel - Channel name
+   */
+  unsubscribe(channel: string): void {
+    const sub = this.channelSubscriptions.get(channel);
+    if (!sub) {
+      return;
+    }
+
+    sub.unsubscribe();
+    this.channelSubscriptions.delete(channel);
+  }
+
+  /**
+   * Unsubscribe from all channels.
+   */
+  unsubscribeAll(): void {
+    if (this.channelSubscriptions.size === 0) {
+      return;
+    }
+
+    this.channelSubscriptions.forEach((sub, channel) => {
+      sub.unsubscribe();
+    });
+    this.channelSubscriptions.clear();
+  }
+
+  /**
+   * Get list of active client-side subscriptions.
+   */
+  getActiveSubscriptions(): string[] {
+    return Array.from(this.channelSubscriptions.keys());
+  }
+
+  /**
+   * Get list of server-side subscriptions (from JWT token).
+   *
+   * These are channels automatically subscribed by Centrifugo server
+   * based on the 'channels' claim in the JWT token.
+   */
+  getServerSideSubscriptions(): string[] {
+    try {
+      // Access Centrifuge.js internal state for server-side subs
+      // @ts-ignore - accessing internal property
+      const serverSubs = this.centrifuge._serverSubs || {};
+      return Object.keys(serverSubs);
+    } catch (error) {
+      return [];
+    }
+  }
+
+  /**
+   * Get all active subscriptions (both client-side and server-side).
+   */
+  getAllSubscriptions(): string[] {
+    const clientSubs = this.getActiveSubscriptions();
+    const serverSubs = this.getServerSideSubscriptions();
+
+    // Combine and deduplicate
+    return Array.from(new Set([...clientSubs, ...serverSubs]));
+  }
 }

django_cfg/apps/integrations/centrifugo/management/commands/generate_centrifugo_clients.py

@@ -10,21 +10,22 @@ import logging
 from pathlib import Path
 from typing import List
 
-from django.core.management.base import BaseCommand, CommandError
+from django.core.management.base import CommandError
 from django.utils.termcolors import colorize
 
+from django_cfg.management.utils import AdminCommand
+
 from django_cfg.apps.integrations.centrifugo.codegen.discovery import discover_rpc_methods_from_router
 from django_cfg.apps.integrations.centrifugo.codegen.generators.python_thin import PythonThinGenerator
 from django_cfg.apps.integrations.centrifugo.codegen.generators.typescript_thin import TypeScriptThinGenerator
 from django_cfg.apps.integrations.centrifugo.codegen.generators.go_thin import GoThinGenerator
 from django_cfg.apps.integrations.centrifugo.router import get_global_router
 
-logger = logging.getLogger(__name__)
-
 
-class Command(BaseCommand):
+class Command(AdminCommand):
     """Generate type-safe client SDKs for Centrifugo WebSocket RPC."""
 
+    command_name = 'generate_centrifugo_clients'
     help = "Generate type-safe client SDKs for Centrifugo WebSocket RPC from @websocket_rpc handlers"
 
     def add_arguments(self, parser):
@@ -131,11 +132,10 @@ class Command(BaseCommand):
         if not methods:
             self.stdout.write(
                 colorize(
-                    "No RPC methods found. Did you register handlers with @websocket_rpc?",
+                    "⚠️  No RPC methods found. Will generate base RPC client without API methods.",
                     fg="yellow",
                 )
             )
-            return
 
         # Create output directory
         output_dir.mkdir(parents=True, exist_ok=True)