django-cfg 1.4.61__py3-none-any.whl → 1.4.63__py3-none-any.whl

django_cfg/apps/ipc/admin.py

@@ -1,212 +0,0 @@
-"""
-Django Admin for IPC/RPC models.
-
-Uses PydanticAdmin with declarative configuration.
-"""
-
-import json
-
-from django.contrib import admin
-from django_cfg.modules.django_admin import (
-    AdminConfig,
-    BadgeField,
-    DateTimeField,
-    Icons,
-    UserField,
-    computed_field,
-)
-from django_cfg.modules.django_admin.base import PydanticAdmin
-
-from .models import RPCLog
-
-
-# Declarative configuration for RPCLog
-rpclog_config = AdminConfig(
-    model=RPCLog,
-
-    # Performance optimization
-    select_related=["user"],
-
-    # List display
-    list_display=[
-        "method",
-        "status",
-        "user",
-        "duration_ms",
-        "created_at",
-        "completed_at"
-    ],
-
-    # Auto-generated display methods
-    display_fields=[
-        BadgeField(
-            name="method",
-            title="RPC Method",
-            variant="info",
-            icon=Icons.API
-        ),
-        BadgeField(
-            name="status",
-            title="Status",
-            label_map={
-                "pending": "warning",
-                "success": "success",
-                "failed": "danger",
-                "timeout": "danger"
-            }
-        ),
-        UserField(
-            name="user",
-            title="User",
-            header=True  # Show with avatar
-        ),
-        DateTimeField(
-            name="created_at",
-            title="Created",
-            ordering="created_at"
-        ),
-        DateTimeField(
-            name="completed_at",
-            title="Completed",
-            ordering="completed_at"
-        ),
-    ],
-
-    # Filters
-    list_filter=["status", "method", "created_at"],
-    search_fields=["method", "correlation_id", "user__username", "user__email", "error_message"],
-
-    # Readonly fields (custom methods below)
-    readonly_fields=[
-        "id",
-        "correlation_id",
-        "created_at",
-        "completed_at",
-        "params_display",
-        "response_display",
-        "error_details_display"
-    ],
-
-    # Date hierarchy
-    date_hierarchy="created_at",
-
-    # Per page
-    list_per_page=50,
-)
-
-
-@admin.register(RPCLog)
-class RPCLogAdmin(PydanticAdmin):
-    """
-    RPC log admin with analytics and filtering.
-
-    Features:
-    - Color-coded status badges
-    - Duration display with performance indicators
-    - Formatted JSON for params/response
-    - Error details with highlighted display
-    """
-    config = rpclog_config
-
-    @computed_field("Duration", ordering="duration_ms")
-    def duration_display(self, obj):
-        """Display duration with color coding based on speed."""
-        if obj.duration_ms is None:
-            return self.html.empty()
-
-        # Color code based on duration
-        if obj.duration_ms < 100:
-            variant = "success"  # Fast
-            icon = Icons.SPEED
-        elif obj.duration_ms < 500:
-            variant = "warning"  # Moderate
-            icon = Icons.TIMER
-        else:
-            variant = "danger"  # Slow
-            icon = Icons.ERROR
-
-        return self.html.badge(
-            f"{obj.duration_ms}ms",
-            variant=variant,
-            icon=icon
-        )
-
-    def params_display(self, obj):
-        """Display formatted JSON params."""
-        if not obj.params:
-            return self.html.empty("No parameters")
-
-        try:
-            formatted = json.dumps(obj.params, indent=2)
-            return f'<pre style="background: #f5f5f5; padding: 10px; border-radius: 4px; max-height: 400px; overflow: auto; font-size: 12px; line-height: 1.5;">{formatted}</pre>'
-        except Exception:
-            return str(obj.params)
-
-    params_display.short_description = "Request Parameters"
-
-    def response_display(self, obj):
-        """Display formatted JSON response."""
-        if not obj.response:
-            return self.html.empty("No response")
-
-        try:
-            formatted = json.dumps(obj.response, indent=2)
-            return f'<pre style="background: #f5f5f5; padding: 10px; border-radius: 4px; max-height: 400px; overflow: auto; font-size: 12px; line-height: 1.5;">{formatted}</pre>'
-        except Exception:
-            return str(obj.response)
-
-    response_display.short_description = "Response Data"
-
-    def error_details_display(self, obj):
-        """Display error information if call failed."""
-        if not obj.is_failed:
-            return self.html.inline([
-                self.html.icon(Icons.CHECK_CIRCLE, size="sm"),
-                self.html.span("No errors", "text-green-600")
-            ])
-
-        details = []
-
-        if obj.error_code:
-            details.append(self.html.inline([
-                self.html.span("Error Code:", "font-semibold"),
-                self.html.badge(obj.error_code, variant="danger", icon=Icons.ERROR)
-            ], separator=" "))
-
-        if obj.error_message:
-            details.append(self.html.inline([
-                self.html.span("Message:", "font-semibold"),
-                self.html.span(obj.error_message, "text-red-600")
-            ], separator=" "))
-
-        return "<br>".join(details) if details else self.html.empty()
-
-    error_details_display.short_description = "Error Details"
-
-    # Fieldsets for detail view
-    def get_fieldsets(self, request, obj=None):
-        """Dynamic fieldsets based on object state."""
-        fieldsets = [
-            ("RPC Call Information", {
-                'fields': ('id', 'correlation_id', 'method', 'user', 'status')
-            }),
-            ("Request & Response", {
-                'fields': ('params_display', 'response_display'),
-                'classes': ('collapse',)
-            }),
-            ("Performance", {
-                'fields': ('duration_ms', 'created_at', 'completed_at')
-            }),
-            ("Metadata", {
-                'fields': ('caller_ip', 'user_agent'),
-                'classes': ('collapse',)
-            }),
-        ]
-
-        # Add error section only if failed
-        if obj and obj.is_failed:
-            fieldsets.insert(2, ("Error Details", {
-                'fields': ('error_details_display', 'error_code', 'error_message')
-            }))
-
-        return fieldsets

django_cfg/apps/ipc/apps.py

@@ -1,28 +0,0 @@
-"""
-Django app configuration for IPC/RPC module.
-
-Provides RPC client and monitoring dashboard.
-"""
-
-from django.apps import AppConfig
-
-
-class IPCConfig(AppConfig):
-    """
-    IPC/RPC application configuration.
-
-    Provides:
-    - RPC client for inter-service communication
-    - Monitoring dashboard with real-time stats
-    - DRF API endpoints for dashboard
-    """
-
-    default_auto_field = 'django.db.models.BigAutoField'
-    name = 'django_cfg.apps.ipc'
-    label = 'django_cfg_ipc'
-    verbose_name = 'IPC/RPC System'
-
-    def ready(self):
-        """Initialize app when Django starts."""
-        # Import monitor to ensure Redis connection is initialized
-        from .services import monitor  # noqa: F401

django_cfg/apps/ipc/migrations/0001_initial.py

@@ -1,137 +0,0 @@
-# Generated by Django 5.2.7 on 2025-10-23 12:12
-
-import django.db.models.deletion
-import django.utils.timezone
-import uuid
-from django.conf import settings
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-    initial = True
-
-    dependencies = [
-        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
-    ]
-
-    operations = [
-        migrations.CreateModel(
-            name="RPCLog",
-            fields=[
-                (
-                    "id",
-                    models.UUIDField(
-                        default=uuid.uuid4, editable=False, primary_key=True, serialize=False
-                    ),
-                ),
-                (
-                    "correlation_id",
-                    models.CharField(
-                        db_index=True,
-                        help_text="UUID from RPC request",
-                        max_length=100,
-                        verbose_name="Correlation ID",
-                    ),
-                ),
-                (
-                    "method",
-                    models.CharField(
-                        db_index=True,
-                        help_text="e.g., send_notification, workspace.file_changed",
-                        max_length=100,
-                        verbose_name="RPC Method",
-                    ),
-                ),
-                (
-                    "params",
-                    models.JSONField(
-                        help_text="Parameters sent to RPC method", verbose_name="Request Params"
-                    ),
-                ),
-                (
-                    "response",
-                    models.JSONField(
-                        blank=True,
-                        help_text="Result from RPC call",
-                        null=True,
-                        verbose_name="Response Data",
-                    ),
-                ),
-                (
-                    "status",
-                    models.CharField(
-                        choices=[
-                            ("pending", "Pending"),
-                            ("success", "Success"),
-                            ("failed", "Failed"),
-                            ("timeout", "Timeout"),
-                        ],
-                        db_index=True,
-                        default="pending",
-                        max_length=20,
-                        verbose_name="Status",
-                    ),
-                ),
-                (
-                    "error_code",
-                    models.CharField(
-                        blank=True, max_length=50, null=True, verbose_name="Error Code"
-                    ),
-                ),
-                (
-                    "error_message",
-                    models.TextField(blank=True, null=True, verbose_name="Error Message"),
-                ),
-                (
-                    "duration_ms",
-                    models.IntegerField(
-                        blank=True,
-                        help_text="Time taken for RPC call in milliseconds",
-                        null=True,
-                        verbose_name="Duration (ms)",
-                    ),
-                ),
-                (
-                    "caller_ip",
-                    models.GenericIPAddressField(blank=True, null=True, verbose_name="Caller IP"),
-                ),
-                ("user_agent", models.TextField(blank=True, null=True, verbose_name="User Agent")),
-                (
-                    "created_at",
-                    models.DateTimeField(
-                        db_index=True, default=django.utils.timezone.now, verbose_name="Created At"
-                    ),
-                ),
-                (
-                    "completed_at",
-                    models.DateTimeField(blank=True, null=True, verbose_name="Completed At"),
-                ),
-                (
-                    "user",
-                    models.ForeignKey(
-                        blank=True,
-                        null=True,
-                        on_delete=django.db.models.deletion.SET_NULL,
-                        related_name="rpc_logs",
-                        to=settings.AUTH_USER_MODEL,
-                        verbose_name="User",
-                    ),
-                ),
-            ],
-            options={
-                "verbose_name": "RPC Log",
-                "verbose_name_plural": "RPC Logs",
-                "ordering": ["-created_at"],
-                "indexes": [
-                    models.Index(fields=["method", "status"], name="django_cfg__method_916fd9_idx"),
-                    models.Index(
-                        fields=["status", "created_at"], name="django_cfg__status_ee629e_idx"
-                    ),
-                    models.Index(fields=["correlation_id"], name="django_cfg__correla_fc7bcf_idx"),
-                    models.Index(
-                        fields=["user", "created_at"], name="django_cfg__user_id_c33866_idx"
-                    ),
-                ],
-            },
-        ),
-    ]

django_cfg/apps/ipc/models.py

@@ -1,221 +0,0 @@
-"""
-IPC/RPC Models for logging and monitoring.
-
-Models:
-- RPCLog: Log of all RPC calls for debugging and analytics
-"""
-
-import uuid
-from django.conf import settings
-from django.db import models
-from django.utils import timezone
-
-
-class RPCLogManager(models.Manager):
-    """Custom manager for RPCLog model."""
-
-    def recent(self, hours=24):
-        """Get logs from last N hours."""
-        since = timezone.now() - timezone.timedelta(hours=hours)
-        return self.filter(created_at__gte=since)
-
-    def failed(self):
-        """Get failed RPC calls."""
-        return self.filter(status=RPCLog.StatusChoices.FAILED)
-
-    def by_method(self, method):
-        """Get logs for specific RPC method."""
-        return self.filter(method=method)
-
-    def stats_by_method(self):
-        """
-        Get statistics grouped by method.
-
-        Returns:
-            QuerySet with aggregated data per method
-        """
-        from django.db.models import Count, Avg, Max, Min
-
-        return self.values('method').annotate(
-            total_calls=Count('id'),
-            avg_duration_ms=Avg('duration_ms'),
-            max_duration_ms=Max('duration_ms'),
-            min_duration_ms=Min('duration_ms'),
-            success_count=Count('id', filter=models.Q(status='success')),
-            failed_count=Count('id', filter=models.Q(status='failed')),
-        ).order_by('-total_calls')
-
-
-class RPCLog(models.Model):
-    """
-    Log of RPC calls between Django and WebSocket server.
-
-    Used for:
-    - Debugging RPC communication
-    - Performance monitoring
-    - Analytics (most used methods, success rate)
-    - Audit trail (who called what and when)
-    """
-
-    class StatusChoices(models.TextChoices):
-        PENDING = 'pending', 'Pending'
-        SUCCESS = 'success', 'Success'
-        FAILED = 'failed', 'Failed'
-        TIMEOUT = 'timeout', 'Timeout'
-
-    # Primary key
-    id = models.UUIDField(
-        primary_key=True,
-        default=uuid.uuid4,
-        editable=False
-    )
-
-    # Correlation ID (matches RPC correlation_id)
-    correlation_id = models.CharField(
-        max_length=100,
-        db_index=True,
-        verbose_name="Correlation ID",
-        help_text="UUID from RPC request"
-    )
-
-    # User who initiated the call (optional)
-    user = models.ForeignKey(
-        settings.AUTH_USER_MODEL,
-        on_delete=models.SET_NULL,
-        null=True,
-        blank=True,
-        related_name='rpc_logs',
-        verbose_name="User"
-    )
-
-    # RPC method name
-    method = models.CharField(
-        max_length=100,
-        db_index=True,
-        verbose_name="RPC Method",
-        help_text="e.g., send_notification, workspace.file_changed"
-    )
-
-    # Request parameters (JSON)
-    params = models.JSONField(
-        verbose_name="Request Params",
-        help_text="Parameters sent to RPC method"
-    )
-
-    # Response data (JSON, nullable if failed)
-    response = models.JSONField(
-        null=True,
-        blank=True,
-        verbose_name="Response Data",
-        help_text="Result from RPC call"
-    )
-
-    # Status
-    status = models.CharField(
-        max_length=20,
-        choices=StatusChoices.choices,
-        default=StatusChoices.PENDING,
-        db_index=True,
-        verbose_name="Status"
-    )
-
-    # Error details (if failed)
-    error_code = models.CharField(
-        max_length=50,
-        null=True,
-        blank=True,
-        verbose_name="Error Code"
-    )
-    error_message = models.TextField(
-        null=True,
-        blank=True,
-        verbose_name="Error Message"
-    )
-
-    # Performance metrics
-    duration_ms = models.IntegerField(
-        null=True,
-        blank=True,
-        verbose_name="Duration (ms)",
-        help_text="Time taken for RPC call in milliseconds"
-    )
-
-    # Metadata
-    caller_ip = models.GenericIPAddressField(
-        null=True,
-        blank=True,
-        verbose_name="Caller IP"
-    )
-    user_agent = models.TextField(
-        null=True,
-        blank=True,
-        verbose_name="User Agent"
-    )
-
-    # Timestamps
-    created_at = models.DateTimeField(
-        default=timezone.now,
-        db_index=True,
-        verbose_name="Created At"
-    )
-    completed_at = models.DateTimeField(
-        null=True,
-        blank=True,
-        verbose_name="Completed At"
-    )
-
-    # Custom manager
-    objects = RPCLogManager()
-
-    class Meta:
-        app_label = 'django_cfg_ipc'
-        verbose_name = "RPC Log"
-        verbose_name_plural = "RPC Logs"
-        ordering = ['-created_at']
-        indexes = [
-            models.Index(fields=['method', 'status']),
-            models.Index(fields=['status', 'created_at']),
-            models.Index(fields=['correlation_id']),
-            models.Index(fields=['user', 'created_at']),
-        ]
-
-    def __str__(self):
-        return f"{self.method} ({self.status}) - {self.created_at.strftime('%Y-%m-%d %H:%M:%S')}"
-
-    @property
-    def is_successful(self):
-        """Check if RPC call was successful."""
-        return self.status == self.StatusChoices.SUCCESS
-
-    @property
-    def is_failed(self):
-        """Check if RPC call failed."""
-        return self.status in [self.StatusChoices.FAILED, self.StatusChoices.TIMEOUT]
-
-    def mark_success(self, response_data, duration_ms=None):
-        """Mark RPC call as successful."""
-        self.status = self.StatusChoices.SUCCESS
-        self.response = response_data
-        self.completed_at = timezone.now()
-        if duration_ms is not None:
-            self.duration_ms = duration_ms
-        self.save()
-
-    def mark_failed(self, error_code, error_message, duration_ms=None):
-        """Mark RPC call as failed."""
-        self.status = self.StatusChoices.FAILED
-        self.error_code = error_code
-        self.error_message = error_message
-        self.completed_at = timezone.now()
-        if duration_ms is not None:
-            self.duration_ms = duration_ms
-        self.save()
-
-    def mark_timeout(self, timeout_seconds):
-        """Mark RPC call as timed out."""
-        self.status = self.StatusChoices.TIMEOUT
-        self.error_code = 'timeout'
-        self.error_message = f'RPC call timed out after {timeout_seconds}s'
-        self.completed_at = timezone.now()
-        self.duration_ms = timeout_seconds * 1000
-        self.save()

django_cfg/apps/ipc/serializers/__init__.py

@@ -1,29 +0,0 @@
-"""
-Serializers for IPC/RPC module.
-"""
-
-from .serializers import (
-    HealthCheckSerializer,
-    LoadTestRequestSerializer,
-    LoadTestResponseSerializer,
-    LoadTestStatusSerializer,
-    MethodStatsSerializer,
-    NotificationStatsSerializer,
-    OverviewStatsSerializer,
-    RecentRequestsSerializer,
-    TestRPCRequestSerializer,
-    TestRPCResponseSerializer,
-)
-
-__all__ = [
-    'HealthCheckSerializer',
-    'OverviewStatsSerializer',
-    'RecentRequestsSerializer',
-    'NotificationStatsSerializer',
-    'MethodStatsSerializer',
-    'TestRPCRequestSerializer',
-    'TestRPCResponseSerializer',
-    'LoadTestRequestSerializer',
-    'LoadTestResponseSerializer',
-    'LoadTestStatusSerializer',
-]