django-cfg 1.4.59__py3-none-any.whl → 1.4.60__py3-none-any.whl

django_cfg/modules/django_dashboard/sections/widgets.py

@@ -0,0 +1,209 @@
+"""Widgets section for dashboard.
+
+Automatically renders widgets from DashboardManager.get_widgets_config()
+"""
+
+from datetime import timedelta
+from typing import Any, Dict, List
+
+import psutil
+from django.db.models import Avg
+from django.template import Context, Template
+from django.utils import timezone
+
+from .base import DataSection
+
+
+class WidgetsSection(DataSection):
+    """
+    Widgets section showing automatically generated dashboard widgets.
+
+    Widgets are defined in DashboardManager.get_widgets_config() and
+    can include:
+    - System metrics (CPU, Memory, Disk)
+    - RPC monitoring stats
+    - Custom application widgets
+    """
+
+    template_name = "admin/sections/widgets_section.html"
+    title = "Dashboard Widgets"
+    icon = "widgets"
+
+    def get_data(self) -> Dict[str, Any]:
+        """Get widgets configuration from DashboardManager."""
+        from django_cfg.modules.django_unfold.dashboard import get_dashboard_manager
+
+        dashboard_manager = get_dashboard_manager()
+
+        # Get widgets from dashboard manager (base system widgets)
+        widgets = dashboard_manager.get_widgets_config()
+
+        return {
+            'widgets': widgets,
+            'widgets_count': len(widgets),
+            'has_widgets': len(widgets) > 0,
+        }
+
+    def merge_custom_widgets(self, widgets: List[Dict], custom_widgets: List[Any]) -> List[Dict]:
+        """
+        Merge custom widgets from dashboard_callback.
+
+        Allows projects to add widgets via dashboard_callback:
+            context["custom_widgets"] = [
+                StatsCardsWidget(...),
+                ...
+            ]
+        """
+        if not custom_widgets:
+            return widgets
+
+        # Convert custom widgets to dicts if they are Pydantic models
+        for widget in custom_widgets:
+            if hasattr(widget, 'to_dict'):
+                widgets.append(widget.to_dict())
+            elif hasattr(widget, 'model_dump'):
+                widgets.append(widget.model_dump())
+            elif isinstance(widget, dict):
+                widgets.append(widget)
+
+        return widgets
+
+    def get_context_data(self, **kwargs) -> Dict[str, Any]:
+        """Add additional context for widget rendering."""
+        context = super().get_context_data(**kwargs)
+
+        # Get base widgets from DashboardManager
+        widgets = context['data']['widgets']
+
+        # Merge custom widgets from dashboard_callback if provided
+        custom_widgets_from_callback = kwargs.get('custom_widgets', [])
+        if custom_widgets_from_callback:
+            widgets = self.merge_custom_widgets(widgets, custom_widgets_from_callback)
+            # Update count
+            context['data']['widgets_count'] = len(widgets)
+            context['data']['has_widgets'] = len(widgets) > 0
+
+        # Get metrics data first
+        metrics_data = {}
+        metrics_data.update(self.get_system_metrics())
+
+        # Add RPC metrics if enabled
+        dashboard_manager = self._get_dashboard_manager()
+        if dashboard_manager.is_rpc_enabled():
+            metrics_data.update(self.get_rpc_metrics())
+
+        # Also merge any custom metrics from kwargs
+        custom_metrics = kwargs.get('custom_metrics', {})
+        if custom_metrics:
+            metrics_data.update(custom_metrics)
+
+        # Process widgets and resolve template variables
+        processed_stats_widgets = []
+        for widget in widgets:
+            if widget.get('type') == 'stats_cards':
+                processed_widget = self._process_stats_widget(widget, metrics_data)
+                processed_stats_widgets.append(processed_widget)
+
+        chart_widgets = [w for w in widgets if w.get('type') == 'chart']
+        custom_widgets = [w for w in widgets if w.get('type') not in ['stats_cards', 'chart']]
+
+        # Add processed widgets
+        context.update({
+            'stats_widgets': processed_stats_widgets,
+            'chart_widgets': chart_widgets,
+            'custom_widgets': custom_widgets,
+        })
+
+        # Also add metrics for direct access
+        context.update(metrics_data)
+
+        return context
+
+    def _get_dashboard_manager(self):
+        """Get dashboard manager instance (lazy import to avoid circular dependencies)."""
+        from django_cfg.modules.django_unfold.dashboard import get_dashboard_manager
+        return get_dashboard_manager()
+
+    def _process_stats_widget(self, widget: Dict[str, Any], context_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Process StatsCardsWidget and resolve template variables in cards."""
+        processed_widget = widget.copy()
+        processed_cards = []
+
+        for card in widget.get('cards', []):
+            processed_card = card.copy()
+
+            # Resolve value_template using Django template engine
+            value_template = card.get('value_template', '')
+            if '{{' in value_template:
+                try:
+                    template = Template(value_template)
+                    context = Context(context_data)
+                    resolved_value = template.render(context)
+                    processed_card['value_template'] = resolved_value
+                except Exception:
+                    # Keep original if rendering fails
+                    pass
+
+            # Also resolve change field if it has template variables
+            change_template = card.get('change', '')
+            if change_template and '{{' in change_template:
+                try:
+                    template = Template(change_template)
+                    context = Context(context_data)
+                    resolved_change = template.render(context)
+                    processed_card['change'] = resolved_change
+                except Exception:
+                    # Keep original if rendering fails
+                    pass
+
+            processed_cards.append(processed_card)
+
+        processed_widget['cards'] = processed_cards
+        return processed_widget
+
+    def get_system_metrics(self) -> Dict[str, Any]:
+        """Get system metrics for widgets."""
+        return {
+            'cpu_percent': round(psutil.cpu_percent(interval=0.1), 1),
+            'memory_percent': round(psutil.virtual_memory().percent, 1),
+            'disk_percent': round(psutil.disk_usage('/').percent, 1),
+        }
+
+    def get_rpc_metrics(self) -> Dict[str, Any]:
+        """Get RPC metrics for widgets."""
+        try:
+            from django_cfg.apps.ipc.models import RPCLog
+
+            # Get stats for last 24 hours
+            since = timezone.now() - timedelta(hours=24)
+
+            logs = RPCLog.objects.filter(timestamp__gte=since)
+
+            total_calls = logs.count()
+            successful_calls = logs.filter(status='success').count()
+            failed_calls = logs.filter(status='error').count()
+
+            success_rate = round((successful_calls / total_calls * 100) if total_calls > 0 else 0, 1)
+
+            avg_duration = logs.filter(
+                duration__isnull=False
+            ).aggregate(
+                avg=Avg('duration')
+            )['avg']
+
+            avg_duration = round(avg_duration * 1000, 1) if avg_duration else 0  # Convert to ms
+
+            return {
+                'rpc_total_calls': total_calls,
+                'rpc_success_rate': success_rate,
+                'rpc_avg_duration': avg_duration,
+                'rpc_failed_calls': failed_calls,
+            }
+        except Exception as e:
+            # Return zeros if RPC models not available
+            return {
+                'rpc_total_calls': 0,
+                'rpc_success_rate': 0,
+                'rpc_avg_duration': 0,
+                'rpc_failed_calls': 0,
+            }

django_cfg/modules/django_unfold/callbacks/main.py

@@ -19,6 +19,7 @@ from django_cfg.modules.django_dashboard.sections.documentation import Documenta
 from django_cfg.modules.django_dashboard.sections.overview import OverviewSection
 from django_cfg.modules.django_dashboard.sections.stats import StatsSection
 from django_cfg.modules.django_dashboard.sections.system import SystemSection
+from django_cfg.modules.django_dashboard.sections.widgets import WidgetsSection
 
 from ...base import BaseCfgModule
 from ..models.dashboard import DashboardData
@@ -155,6 +156,29 @@ class UnfoldCallbacks(
                 logger.error(f"Failed to render documentation section: {e}", exc_info=True)
                 documentation_section = None
 
+            # Extract custom widgets from context if provided by project's dashboard_callback
+            custom_widgets = context.get('custom_widgets', [])
+            custom_metrics = {}
+
+            # Extract all metric-like variables from context for widget template resolution
+            # This allows dashboard_callback to add metrics like: context['total_users'] = 123
+            for key, value in context.items():
+                if key not in ['request', 'cards', 'system_health', 'quick_actions'] and isinstance(value, (int, float, str)):
+                    custom_metrics[key] = value
+
+            try:
+                # Render widgets section with custom widgets and metrics from callback
+                widgets_section = WidgetsSection(request).render(
+                    custom_widgets=custom_widgets,
+                    custom_metrics=custom_metrics
+                )
+                # Debug: save render (only in debug mode)
+                if config and config.debug:
+                    save_section_render('widgets', widgets_section)
+            except Exception as e:
+                logger.error(f"Failed to render widgets section: {e}", exc_info=True)
+                widgets_section = None
+
             # Combine all stat cards (data already loaded above)
             all_stats = user_stats + support_stats
 
@@ -176,6 +200,7 @@ class UnfoldCallbacks(
                 "system_section": system_section,
                 "commands_section": commands_section,
                 "documentation_section": documentation_section,
+                "widgets_section": widgets_section,
 
                 # Statistics cards
                 "cards": cards_data,
@@ -252,24 +277,24 @@ class UnfoldCallbacks(
             })
 
             # Log charts data for debugging
-            charts_data = context.get('charts', {})
-            logger.info(f"Charts data added to context: {list(charts_data.keys())}")
-            if 'user_registrations' in charts_data:
-                reg_data = charts_data['user_registrations']
-                logger.info(f"Registration chart labels: {reg_data.get('labels', [])}")
-            if 'user_activity' in charts_data:
-                act_data = charts_data['user_activity']
-                logger.info(f"Activity chart labels: {act_data.get('labels', [])}")
-
-            # Log recent users data for debugging
-            recent_users_data = context.get('recent_users', [])
-            logger.info(f"Recent users data count: {len(recent_users_data)}")
-            if recent_users_data:
-                logger.info(f"First user: {recent_users_data[0].get('username', 'N/A')}")
-
-            # Log activity tracker data for debugging
-            activity_tracker_data = context.get('activity_tracker', [])
-            logger.info(f"Activity tracker data count: {len(activity_tracker_data)}")
+            # charts_data = context.get('charts', {})
+            # # logger.info(f"Charts data added to context: {list(charts_data.keys())}")
+            # if 'user_registrations' in charts_data:
+            #     reg_data = charts_data['user_registrations']
+            #     logger.info(f"Registration chart labels: {reg_data.get('labels', [])}")
+            # if 'user_activity' in charts_data:
+            #     act_data = charts_data['user_activity']
+            #     logger.info(f"Activity chart labels: {act_data.get('labels', [])}")
+
+            # # Log recent users data for debugging
+            # recent_users_data = context.get('recent_users', [])
+            # logger.info(f"Recent users data count: {len(recent_users_data)}")
+            # if recent_users_data:
+            #     logger.info(f"First user: {recent_users_data[0].get('username', 'N/A')}")
+
+            # # Log activity tracker data for debugging
+            # activity_tracker_data = context.get('activity_tracker', [])
+            # logger.info(f"Activity tracker data count: {len(activity_tracker_data)}")
 
             return context
 

django_cfg/modules/django_unfold/dashboard.py

@@ -73,9 +73,10 @@ class DashboardManager(BaseCfgModule):
 
         # RPC Dashboard (if enabled)
         if self.is_rpc_enabled():
-            operations_items.append(
-                NavigationItem(title="IPC/RPC Dashboard", icon=Icons.MONITOR_HEART, link="/cfg/ipc/admin/")
-            )
+            operations_items.extend([
+                NavigationItem(title="IPC/RPC Dashboard", icon=Icons.MONITOR_HEART, link="/cfg/ipc/admin/"),
+                NavigationItem(title="RPC Logs", icon=Icons.LIST_ALT, link=str(reverse_lazy("admin:django_cfg_ipc_rpclog_changelist"))),
+            ])
 
         # Background Tasks (if enabled)
         if self.should_enable_tasks():
@@ -298,6 +299,8 @@ class DashboardManager(BaseCfgModule):
 
     def get_widgets_config(self) -> List[Dict[str, Any]]:
         """Get dashboard widgets configuration using Pydantic models."""
+        widgets = []
+
         # Create system overview widget with StatCard models
         system_overview_widget = StatsCardsWidget(
             title="System Overview",
@@ -322,9 +325,43 @@ class DashboardManager(BaseCfgModule):
                 ),
             ]
         )
+        widgets.append(system_overview_widget.to_dict())
+
+        # Add RPC monitoring widget if IPC is enabled
+        if self.is_rpc_enabled():
+            rpc_monitoring_widget = StatsCardsWidget(
+                title="IPC/RPC Monitoring",
+                cards=[
+                    StatCard(
+                        title="Total Calls",
+                        value="{{ rpc_total_calls }}",
+                        icon=Icons.API,
+                        color="blue",
+                    ),
+                    StatCard(
+                        title="Success Rate",
+                        value="{{ rpc_success_rate }}%",
+                        icon=Icons.CHECK_CIRCLE,
+                        color="green",
+                    ),
+                    StatCard(
+                        title="Avg Response Time",
+                        value="{{ rpc_avg_duration }}ms",
+                        icon=Icons.SPEED,
+                        color="purple",
+                    ),
+                    StatCard(
+                        title="Failed Calls",
+                        value="{{ rpc_failed_calls }}",
+                        icon=Icons.ERROR,
+                        color="red",
+                    ),
+                ]
+            )
+            widgets.append(rpc_monitoring_widget.to_dict())
 
         # Convert to dictionaries for Unfold
-        return [system_overview_widget.to_dict()]
+        return widgets
 
 
 # Lazy initialization to avoid circular imports

django_cfg/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "django-cfg"
-version = "1.4.59"
+version = "1.4.60"
 description = "Django AI framework with built-in agents, type-safe Pydantic v2 configuration, and 8 enterprise apps. Replace settings.py, validate at startup, 90% less code. Production-ready AI workflows for Django."
 readme = "README.md"
 keywords = [ "django", "configuration", "pydantic", "settings", "type-safety", "pydantic-settings", "django-environ", "startup-validation", "ide-autocomplete", "ai-agents", "enterprise-django", "django-settings", "type-safe-config",]

django_cfg/static/js/api/index.mjs

@@ -7,22 +7,23 @@
  *
  * @example
  * // Import specific app API
- * import { tasksAPI } from '/static/js/api/tasks/index.mjs';
+ * import { tasksAPI } from '/static/api/tasks/index.mjs';
  * const stats = await tasksAPI.cfgTasksApiTasksStatsRetrieve();
  *
  * @example
  * // Import multiple APIs from main index
- * import { tasksAPI, paymentsAPI } from '/static/js/api/index.mjs';
+ * import { tasksAPI, paymentsAPI } from '/static/api/index.mjs';
  *
  * @example
  * // Import with custom base URL
- * import { TasksAPI } from '/static/js/api/tasks/index.mjs';
+ * import { TasksAPI } from '/static/api/tasks/index.mjs';
  * const api = new TasksAPI('https://api.example.com');
  */
 
 import { BaseAPIClient } from './base.mjs';
 import { AccountsAPI, accountsAPI } from './accounts/index.mjs';
 import { IpcAPI, ipcAPI } from './ipc/index.mjs';
+import { KnowbaseAPI, knowbaseAPI } from './knowbase/index.mjs';
 import { LeadsAPI, leadsAPI } from './leads/index.mjs';
 import { NewsletterAPI, newsletterAPI } from './newsletter/index.mjs';
 import { PaymentsAPI, paymentsAPI } from './payments/index.mjs';
@@ -37,6 +38,7 @@ export {
     BaseAPIClient,
     AccountsAPI,
     IpcAPI,
+    KnowbaseAPI,
     LeadsAPI,
     NewsletterAPI,
     PaymentsAPI,
@@ -52,6 +54,7 @@ export {
 export {
     accountsAPI,
     ipcAPI,
+    knowbaseAPI,
     leadsAPI,
     newsletterAPI,
     paymentsAPI,
@@ -67,6 +70,7 @@ export {
 export const apis = {
     accounts: accountsAPI,
     ipc: ipcAPI,
+    knowbase: knowbaseAPI,
     leads: leadsAPI,
     newsletter: newsletterAPI,
     payments: paymentsAPI,
@@ -92,6 +96,7 @@ export function getAPI(appName) {
 export const availableApps = [
     'accounts',
     'ipc',
+    'knowbase',
     'leads',
     'newsletter',
     'payments',

django_cfg/static/js/api/ipc/client.mjs

@@ -40,6 +40,26 @@ export class IpcAPI extends BaseAPIClient {
      */
     async ipcAdminApiMonitorRequestsRetrieve(params = {}) {
         const path = `/cfg/ipc/admin/api/monitor/requests/`;        return this.get(path, params);    }
+    /**
+     * Start load test     * Start a load test by sending multiple concurrent RPC requests.     * @param {LoadTestRequestRequest} data - Request body     * @returns {Promise<LoadTestResponse>} Response data
+     */
+    async ipcAdminApiTestLoadStartCreate(data) {
+        const path = `/cfg/ipc/admin/api/test/load/start/`;        return this.post(path, data);    }
+    /**
+     * Get load test status     * Get current status of running or completed load test.     * @returns {Promise<LoadTestStatus>} Response data
+     */
+    async ipcAdminApiTestLoadStatusRetrieve() {
+        const path = `/cfg/ipc/admin/api/test/load/status/`;        return this.get(path);    }
+    /**
+     * Stop load test     * Stop currently running load test.     * @param {TestRPCRequestRequest} data - Request body     * @returns {Promise<any>} Response data
+     */
+    async ipcAdminApiTestLoadStopCreate(data) {
+        const path = `/cfg/ipc/admin/api/test/load/stop/`;        return this.post(path, data);    }
+    /**
+     * Send test RPC request     * Send a single RPC request for testing purposes and measure response time.     * @param {TestRPCRequestRequest} data - Request body     * @returns {Promise<TestRPCResponse>} Response data
+     */
+    async ipcAdminApiTestSendCreate(data) {
+        const path = `/cfg/ipc/admin/api/test/send/`;        return this.post(path, data);    }
     /**
      * Get RPC health status     * Returns the current health status of the RPC monitoring system.     * @returns {Promise<HealthCheck>} Response data
      */
@@ -65,6 +85,26 @@ export class IpcAPI extends BaseAPIClient {
      */
     async ipcMonitorRequestsRetrieve(params = {}) {
         const path = `/cfg/ipc/monitor/requests/`;        return this.get(path, params);    }
+    /**
+     * Start load test     * Start a load test by sending multiple concurrent RPC requests.     * @param {LoadTestRequestRequest} data - Request body     * @returns {Promise<LoadTestResponse>} Response data
+     */
+    async ipcTestLoadStartCreate(data) {
+        const path = `/cfg/ipc/test/load/start/`;        return this.post(path, data);    }
+    /**
+     * Get load test status     * Get current status of running or completed load test.     * @returns {Promise<LoadTestStatus>} Response data
+     */
+    async ipcTestLoadStatusRetrieve() {
+        const path = `/cfg/ipc/test/load/status/`;        return this.get(path);    }
+    /**
+     * Stop load test     * Stop currently running load test.     * @param {TestRPCRequestRequest} data - Request body     * @returns {Promise<any>} Response data
+     */
+    async ipcTestLoadStopCreate(data) {
+        const path = `/cfg/ipc/test/load/stop/`;        return this.post(path, data);    }
+    /**
+     * Send test RPC request     * Send a single RPC request for testing purposes and measure response time.     * @param {TestRPCRequestRequest} data - Request body     * @returns {Promise<TestRPCResponse>} Response data
+     */
+    async ipcTestSendCreate(data) {
+        const path = `/cfg/ipc/test/send/`;        return this.post(path, data);    }
 }
 
 // Default instance for convenience