django-cfg 1.4.120__py3-none-any.whl → 1.5.1__py3-none-any.whl

django_cfg/__init__.py

@@ -32,11 +32,11 @@ Example:
 default_app_config = "django_cfg.apps.DjangoCfgConfig"
 
 # Version information
-__version__ = "1.4.120"
+__version__ = "1.5.1"
 __license__ = "MIT"
 
 # Import registry for organized lazy loading
-from .config import LIB_NAME
+from .config import LIB_NAME, is_feature_available, require_feature, register_feature
 from .registry import DJANGO_CFG_REGISTRY
 
 # Get author from library config
@@ -55,5 +55,9 @@ def __getattr__(name: str):
     raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
 
 
-# Export all registered components
-__all__ = list(DJANGO_CFG_REGISTRY.keys())
+# Export all registered components + feature detection
+__all__ = list(DJANGO_CFG_REGISTRY.keys()) + [
+    "is_feature_available",
+    "require_feature",
+    "register_feature",
+]

django_cfg/apps/centrifugo/admin/centrifugo_log.py

@@ -96,7 +96,7 @@ class CentrifugoLogAdmin(PydanticAdmin):
 
         try:
             formatted = json.dumps(obj.data, 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>'
+            return self.html.code_block(formatted, language="json", max_height="400px")
         except Exception:
             return str(obj.data)
 
@@ -106,37 +106,22 @@ class CentrifugoLogAdmin(PydanticAdmin):
         """Display error information if publish failed."""
         if obj.is_successful or obj.status == "pending":
             return self.html.inline(
-                [
-                    self.html.icon(Icons.CHECK_CIRCLE, size="sm"),
-                    self.html.span("No errors", "text-green-600"),
-                ]
+                self.html.icon(Icons.CHECK_CIRCLE, size="sm"),
+                self.html.text("No errors", variant="success"),
+                separator=" "
             )
 
-        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=" ",
-                )
-            )
+        error_code_line = self.html.key_value(
+            "Error Code",
+            self.html.badge(obj.error_code, variant="danger", icon=Icons.ERROR)
+        ) if obj.error_code else None
 
-        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=" ",
-                )
-            )
+        error_msg_line = self.html.key_value(
+            "Message",
+            self.html.text(obj.error_message, variant="danger")
+        ) if obj.error_message else None
 
-        return "<br>".join(details) if details else self.html.empty()
+        return self.html.breakdown(error_code_line, error_msg_line) if (error_code_line or error_msg_line) else self.html.empty()
 
     error_details_display.short_description = "Error Details"
 
@@ -145,57 +130,34 @@ class CentrifugoLogAdmin(PydanticAdmin):
         if not obj.wait_for_ack:
             return self.html.empty("No ACK tracking")
 
-        stats = []
-
         # ACK timeout
-        if obj.ack_timeout:
-            stats.append(
-                self.html.inline(
-                    [
-                        self.html.span("Timeout:", "font-semibold"),
-                        self.html.span(f"{obj.ack_timeout}s", "text-gray-600"),
-                    ],
-                    separator=" ",
-                )
-            )
+        timeout_line = self.html.key_value(
+            "Timeout",
+            f"{obj.ack_timeout}s"
+        ) if obj.ack_timeout else None
 
         # ACKs received
-        stats.append(
-            self.html.inline(
-                [
-                    self.html.span("ACKs Received:", "font-semibold"),
-                    self.html.badge(str(obj.acks_received), variant="info"),
-                ],
-                separator=" ",
-            )
+        received_line = self.html.key_value(
+            "ACKs Received",
+            self.html.badge(str(obj.acks_received), variant="info")
         )
 
         # ACKs expected (if known)
-        if obj.acks_expected:
-            stats.append(
-                self.html.inline(
-                    [
-                        self.html.span("ACKs Expected:", "font-semibold"),
-                        self.html.span(str(obj.acks_expected), "text-gray-600"),
-                    ],
-                    separator=" ",
-                )
+        expected_line = self.html.key_value(
+            "ACKs Expected",
+            str(obj.acks_expected)
+        ) if obj.acks_expected else None
+
+        # Delivery rate
+        rate_line = None
+        if obj.acks_expected and obj.delivery_rate is not None:
+            rate_pct = obj.delivery_rate * 100
+            rate_line = self.html.key_value(
+                "Delivery Rate",
+                self.html.number(rate_pct, precision=1, suffix="%")
             )
 
-            # Delivery rate
-            if obj.delivery_rate is not None:
-                rate_pct = obj.delivery_rate * 100
-                stats.append(
-                    self.html.inline(
-                        [
-                            self.html.span("Delivery Rate:", "font-semibold"),
-                            self.html.span(f"{rate_pct:.1f}%", "text-blue-600"),
-                        ],
-                        separator=" ",
-                    )
-                )
-
-        return "<br>".join(stats) if stats else self.html.empty()
+        return self.html.breakdown(timeout_line, received_line, expected_line, rate_line)
 
     delivery_stats_display.short_description = "Delivery Statistics"
 

django_cfg/apps/grpc/__init__.py

@@ -0,0 +1,9 @@
+"""
+django_cfg.apps.grpc
+
+gRPC integration for django-cfg with Django ORM, JWT auth, monitoring, and admin interface.
+"""
+
+default_app_config = 'django_cfg.apps.grpc.apps.GRPCAppConfig'
+
+__version__ = '1.0.0'

django_cfg/apps/grpc/admin/__init__.py

@@ -0,0 +1,11 @@
+"""
+Admin interface for gRPC app.
+"""
+
+from .config import grpcrequestlog_config
+from .grpc_request_log import GRPCRequestLogAdmin
+
+__all__ = [
+    "GRPCRequestLogAdmin",
+    "grpcrequestlog_config",
+]

django_cfg/apps/grpc/admin/config.py

@@ -0,0 +1,89 @@
+"""
+Admin configuration for gRPC models.
+
+Declarative AdminConfig using PydanticAdmin patterns.
+"""
+
+from django_cfg.modules.django_admin import (
+    AdminConfig,
+    BadgeField,
+    DateTimeField,
+    Icons,
+    UserField,
+)
+
+from ..models import GRPCRequestLog
+
+
+# Declarative configuration for GRPCRequestLog
+grpcrequestlog_config = AdminConfig(
+    model=GRPCRequestLog,
+    # Performance optimization
+    select_related=["user"],
+
+    # List display
+    list_display=[
+        "full_method",
+        "service_badge",
+        "method_badge",
+        "status",
+        "grpc_status_code_display",
+        "user",
+        "duration_display",
+        "created_at",
+        "completed_at"
+    ],
+
+    # Auto-generated display methods
+    display_fields=[
+        BadgeField(name="service_name", title="Service", variant="info", icon=Icons.API),
+        BadgeField(name="method_name", title="Method", variant="secondary", icon=Icons.CODE),
+        BadgeField(
+            name="status",
+            title="Status",
+            label_map={
+                "pending": "warning",
+                "success": "success",
+                "error": "danger",
+                "cancelled": "secondary",
+                "timeout": "danger",
+            },
+        ),
+        UserField(name="user", title="User", header=True),
+        DateTimeField(name="created_at", title="Created", ordering="created_at"),
+        DateTimeField(name="completed_at", title="Completed", ordering="completed_at"),
+    ],
+    # Filters
+    list_filter=["status", "grpc_status_code", "service_name", "method_name", "is_authenticated", "created_at"],
+    search_fields=[
+        "request_id",
+        "service_name",
+        "method_name",
+        "full_method",
+        "user__username",
+        "user__email",
+        "error_message",
+        "client_ip",
+    ],
+    # Autocomplete for user field
+    autocomplete_fields=["user"],
+    # Readonly fields
+    readonly_fields=[
+        "id",
+        "request_id",
+        "created_at",
+        "completed_at",
+        "request_data_display",
+        "response_data_display",
+        "error_details_display",
+        "performance_stats_display",
+        "client_info_display",
+    ],
+    # Date hierarchy
+    date_hierarchy="created_at",
+    # Per page
+    list_per_page=50,
+)
+
+
+__all__ = ["grpcrequestlog_config"]

django_cfg/apps/grpc/admin/grpc_request_log.py

@@ -0,0 +1,252 @@
+"""
+gRPC Request Log Admin.
+
+PydanticAdmin for GRPCRequestLog model with custom computed fields.
+"""
+
+import json
+
+from django.contrib import admin
+from django_cfg.modules.django_admin import Icons, computed_field
+from django_cfg.modules.django_admin.base import PydanticAdmin
+
+from ..models import GRPCRequestLog
+from .config import grpcrequestlog_config
+
+
+@admin.register(GRPCRequestLog)
+class GRPCRequestLogAdmin(PydanticAdmin):
+    """
+    gRPC request log admin with analytics and filtering.
+
+    Features:
+    - Color-coded status badges
+    - Performance metrics visualization
+    - Duration display with performance indicators
+    - Formatted JSON for request/response data
+    - Error details with highlighted display
+    """
+
+    config = grpcrequestlog_config
+
+    @computed_field("Service", ordering="service_name")
+    def service_badge(self, obj):
+        """Display service name as badge."""
+        return self.html.badge(obj.service_name, variant="info", icon=Icons.API)
+
+    @computed_field("Method", ordering="method_name")
+    def method_badge(self, obj):
+        """Display method name as badge."""
+        return self.html.badge(obj.method_name, variant="secondary", icon=Icons.CODE)
+
+    @computed_field("gRPC Status", ordering="grpc_status_code")
+    def grpc_status_code_display(self, obj):
+        """Display gRPC status code with color coding."""
+        if not obj.grpc_status_code:
+            return self.html.empty()
+
+        # Color code based on status
+        if obj.grpc_status_code == "OK":
+            variant = "success"
+            icon = Icons.CHECK_CIRCLE
+        elif obj.grpc_status_code in ["CANCELLED", "DEADLINE_EXCEEDED"]:
+            variant = "warning"
+            icon = Icons.TIMER
+        else:
+            variant = "danger"
+            icon = Icons.ERROR
+
+        return self.html.badge(obj.grpc_status_code, variant=variant, icon=icon)
+
+    @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 < 1000:
+            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 request_data_display(self, obj):
+        """Display formatted JSON request data."""
+        if not obj.request_data:
+            return self.html.empty("No request data logged")
+
+        try:
+            formatted = json.dumps(obj.request_data, indent=2)
+            return self.html.code_block(formatted, language="json", max_height="400px")
+        except Exception:
+            return str(obj.request_data)
+
+    request_data_display.short_description = "Request Data"
+
+    def response_data_display(self, obj):
+        """Display formatted JSON response data."""
+        if not obj.response_data:
+            return self.html.empty("No response data logged")
+
+        try:
+            formatted = json.dumps(obj.response_data, indent=2)
+            return self.html.code_block(formatted, language="json", max_height="400px")
+        except Exception:
+            return str(obj.response_data)
+
+    response_data_display.short_description = "Response Data"
+
+    def error_details_display(self, obj):
+        """Display error information if request failed."""
+        if obj.is_successful or obj.status == "pending":
+            return self.html.inline(
+                self.html.icon(Icons.CHECK_CIRCLE, size="sm"),
+                self.html.text("No errors", variant="success"),
+                separator=" "
+            )
+
+        # gRPC status code
+        code_line = self.html.key_value(
+            "gRPC Status",
+            self.html.badge(obj.grpc_status_code, variant="danger", icon=Icons.ERROR)
+        ) if obj.grpc_status_code else None
+
+        # Error message
+        msg_line = self.html.key_value(
+            "Message",
+            self.html.text(obj.error_message, variant="danger")
+        ) if obj.error_message else None
+
+        # Error details
+        details_line = None
+        if obj.error_details:
+            try:
+                formatted = json.dumps(obj.error_details, indent=2)
+                details_line = self.html.key_value(
+                    "Details",
+                    self.html.code_block(formatted, language="json", max_height="200px")
+                )
+            except Exception:
+                pass
+
+        return self.html.breakdown(code_line, msg_line, details_line) if (code_line or msg_line) else self.html.empty()
+
+    error_details_display.short_description = "Error Details"
+
+    def performance_stats_display(self, obj):
+        """Display performance statistics."""
+        # Duration
+        duration_line = self.html.key_value(
+            "Duration",
+            self.html.number(obj.duration_ms, suffix="ms") if obj.duration_ms else "N/A"
+        )
+
+        # Request size
+        request_size_line = self.html.key_value(
+            "Request Size",
+            self.html.number(obj.request_size, suffix=" bytes") if obj.request_size else "N/A"
+        )
+
+        # Response size
+        response_size_line = self.html.key_value(
+            "Response Size",
+            self.html.number(obj.response_size, suffix=" bytes") if obj.response_size else "N/A"
+        )
+
+        # Authentication
+        auth_line = self.html.key_value(
+            "Authenticated",
+            self.html.badge("Yes" if obj.is_authenticated else "No",
+                          variant="success" if obj.is_authenticated else "secondary")
+        )
+
+        return self.html.breakdown(duration_line, request_size_line, response_size_line, auth_line)
+
+    performance_stats_display.short_description = "Performance Statistics"
+
+    def client_info_display(self, obj):
+        """Display client information."""
+        # Client IP
+        ip_line = self.html.key_value(
+            "Client IP",
+            obj.client_ip if obj.client_ip else "N/A"
+        )
+
+        # User Agent
+        ua_line = self.html.key_value(
+            "User Agent",
+            obj.user_agent if obj.user_agent else "N/A"
+        )
+
+        # Peer
+        peer_line = self.html.key_value(
+            "Peer",
+            self.html.text(obj.peer, variant="secondary") if obj.peer else "N/A"
+        )
+
+        return self.html.breakdown(ip_line, ua_line, peer_line)
+
+    client_info_display.short_description = "Client Information"
+
+    # Fieldsets for detail view
+    def get_fieldsets(self, request, obj=None):
+        """Dynamic fieldsets based on object state."""
+        fieldsets = [
+            (
+                "Request Information",
+                {"fields": ("id", "request_id", "full_method", "service_name", "method_name", "status")},
+            ),
+            (
+                "User Context",
+                {"fields": ("user", "is_authenticated")},
+            ),
+            (
+                "Performance",
+                {"fields": ("performance_stats_display", "duration_ms", "created_at", "completed_at")},
+            ),
+            (
+                "Client Information",
+                {"fields": ("client_info_display", "client_ip", "user_agent", "peer"), "classes": ("collapse",)},
+            ),
+        ]
+
+        # Add request/response data sections if available
+        if obj and obj.request_data:
+            fieldsets.insert(
+                3,
+                (
+                    "Request Data",
+                    {"fields": ("request_data_display",), "classes": ("collapse",)},
+                ),
+            )
+
+        if obj and obj.response_data:
+            fieldsets.insert(
+                4,
+                (
+                    "Response Data",
+                    {"fields": ("response_data_display",), "classes": ("collapse",)},
+                ),
+            )
+
+        # Add error section only if failed
+        if obj and not obj.is_successful and obj.status != "pending":
+            fieldsets.insert(
+                5,
+                (
+                    "Error Details",
+                    {"fields": ("error_details_display", "grpc_status_code", "error_message", "error_details")},
+                ),
+            )
+
+        return fieldsets
+
+
+__all__ = ["GRPCRequestLogAdmin"]

django_cfg/apps/grpc/apps.py

@@ -0,0 +1,28 @@
+"""
+Django app configuration for gRPC integration.
+"""
+
+from django.apps import AppConfig
+
+
+class GRPCAppConfig(AppConfig):
+    """
+    Django app config for gRPC integration.
+
+    Provides:
+    - gRPC server with Django ORM integration
+    - JWT authentication
+    - Request logging to database
+    - Admin interface for monitoring
+    - REST API for metrics
+    """
+
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'django_cfg.apps.grpc'
+    verbose_name = 'gRPC Integration'
+
+    def ready(self):
+        """Called when Django starts."""
+        # Import signal handlers if needed
+        # from . import signals
+        pass

django_cfg/apps/grpc/auth/__init__.py

@@ -0,0 +1,9 @@
+"""
+gRPC authentication components.
+
+Provides JWT authentication for gRPC services.
+"""
+
+from .jwt_auth import JWTAuthInterceptor
+
+__all__ = ["JWTAuthInterceptor"]