django-cfg 1.4.88__py3-none-any.whl → 1.4.89__py3-none-any.whl

django_cfg/apps/centrifugo/templatetags/centrifugo_tags.py

@@ -1,81 +0,0 @@
-"""
-Centrifugo Template Tags.
-
-Provides template tags for accessing Centrifugo configuration in templates.
-"""
-
-from django import template
-from ..services import get_centrifugo_config
-
-register = template.Library()
-
-
-@register.simple_tag
-def centrifugo_admin_url():
-    """
-    Get Centrifugo admin UI URL from configuration.
-
-    Returns the HTTP admin URL from centrifugo_api_url.
-    Example: http://localhost:8002
-
-    Usage in template:
-        {% load centrifugo_tags %}
-        {% centrifugo_admin_url %}
-    """
-    config = get_centrifugo_config()
-    if not config or not config.centrifugo_api_url:
-        return ""
-
-    # Return HTTP API URL (admin UI is on same host)
-    url = config.centrifugo_api_url
-
-    # Remove /api suffix if present
-    if url.endswith('/api'):
-        url = url[:-len('/api')]
-
-    # Remove trailing slash
-    url = url.rstrip('/')
-
-    return url
-
-
-@register.simple_tag
-def centrifugo_is_configured():
-    """
-    Check if Centrifugo is configured.
-    
-    Returns True if Centrifugo config exists and has URL.
-    
-    Usage in template:
-        {% load centrifugo_tags %}
-        {% centrifugo_is_configured as is_configured %}
-        {% if is_configured %}...{% endif %}
-    """
-    config = get_centrifugo_config()
-    return bool(config and config.centrifugo_url)
-
-
-@register.simple_tag
-def centrifugo_wrapper_url():
-    """
-    Get Centrifugo wrapper URL from configuration.
-    
-    Returns the wrapper URL (our Django proxy).
-    Example: http://localhost:8080
-    
-    Usage in template:
-        {% load centrifugo_tags %}
-        {% centrifugo_wrapper_url %}
-    """
-    config = get_centrifugo_config()
-    if not config or not config.wrapper_url:
-        return ""
-    
-    return config.wrapper_url.rstrip('/')
-
-
-__all__ = [
-    "centrifugo_admin_url",
-    "centrifugo_is_configured",
-    "centrifugo_wrapper_url",
-]

django_cfg/apps/centrifugo/urls_admin.py

@@ -1,20 +0,0 @@
-"""
-Admin URLs for Centrifugo dashboard.
-
-Dashboard interface for monitoring Centrifugo publish activity.
-"""
-
-from django.urls import include, path
-
-from .views import dashboard_view
-
-app_name = 'django_cfg_centrifugo_admin'
-
-
-urlpatterns = [
-    # Dashboard page
-    path('', dashboard_view, name='dashboard'),
-
-    # Include API endpoints for dashboard AJAX calls
-    path('api/', include('django_cfg.apps.centrifugo.urls')),
-]

django_cfg/apps/centrifugo/views/dashboard.py

@@ -1,28 +0,0 @@
-"""
-Dashboard view for Centrifugo monitoring.
-"""
-
-from django.contrib.admin.views.decorators import staff_member_required
-from django.shortcuts import render
-from django.urls import reverse
-
-
-@staff_member_required
-def dashboard_view(request):
-    """Render the Centrifugo dashboard template."""
-
-    # Navigation items for the navbar
-    nav_items = [
-        {
-            'label': 'Logs',
-            'url': reverse('admin:django_cfg_centrifugo_centrifugolog_changelist'),
-            'icon': 'list_alt',
-            'active': False,
-        },
-    ]
-
-    context = {
-        'page_title': 'Centrifugo Monitor Dashboard',
-        'centrifugo_nav_items': nav_items,
-    }
-    return render(request, 'django_cfg_centrifugo/pages/dashboard.html', context)

django_cfg/modules/django_dashboard/__init__.py

@@ -1,23 +0,0 @@
-"""
-Django CFG Dashboard Module.
-
-Section-based architecture for dashboard rendering.
-Inspired by Unfold's clean component approach.
-"""
-
-# Import components to register them with Unfold
-# The @register_component decorator runs on import
-from . import components  # noqa: F401
-from .sections.base import DashboardSection
-from .sections.commands import CommandsSection
-from .sections.overview import OverviewSection
-from .sections.stats import StatsSection
-from .sections.system import SystemSection
-
-__all__ = [
-    'DashboardSection',
-    'OverviewSection',
-    'StatsSection',
-    'SystemSection',
-    'CommandsSection',
-]

django_cfg/modules/django_dashboard/components.py

@@ -1,312 +0,0 @@
-"""
-Dashboard Component Classes
-
-Uses Unfold's Component Class system for data preprocessing.
-Separates business logic from presentation templates.
-"""
-
-from typing import Any, Dict
-
-from unfold.components import BaseComponent, register_component
-
-
-@register_component
-class SystemMetricsComponent(BaseComponent):
-    """
-    System metrics component for dashboard.
-
-    Provides health metrics for database, cache, storage, and API.
-    """
-
-    def get_context_data(self, **kwargs):
-        """Prepare system metrics data."""
-        context = super().get_context_data(**kwargs)
-        context.update({
-            "data": self.get_system_metrics()
-        })
-        return context
-
-    def get_system_metrics(self) -> Dict[str, Any]:
-        """Fetch system health metrics."""
-        import shutil
-
-        from django.core.cache import cache
-        from django.db import connection
-
-        metrics = {}
-
-        # Database Health
-        try:
-            with connection.cursor() as cursor:
-                cursor.execute("SELECT 1")
-                metrics["database"] = {
-                    "value": 95,
-                    "title": "Database Health",
-                    "description": "Connection successful",
-                }
-        except Exception as e:
-            metrics["database"] = {
-                "value": 0,
-                "title": "Database Health",
-                "description": f"Error: {str(e)[:50]}",
-            }
-
-        # Cache Performance
-        try:
-            cache.set("health_check", "ok", 10)
-            if cache.get("health_check") == "ok":
-                metrics["cache"] = {
-                    "value": 90,
-                    "title": "Cache Performance",
-                    "description": "Cache working properly",
-                }
-            else:
-                metrics["cache"] = {
-                    "value": 50,
-                    "title": "Cache Performance",
-                    "description": "Cache response delayed",
-                }
-        except Exception as e:
-            metrics["cache"] = {
-                "value": 0,
-                "title": "Cache Performance",
-                "description": f"Error: {str(e)[:50]}",
-            }
-
-        # Storage Space
-        try:
-            total, used, free = shutil.disk_usage("/")
-            free_percentage = int((free / total) * 100)
-            usage_percentage = 100 - free_percentage
-
-            metrics["storage"] = {
-                "value": free_percentage,
-                "title": "Disk Space",
-                "description": f"{free_percentage}% free ({usage_percentage}% used)",
-            }
-        except Exception as e:
-            metrics["storage"] = {
-                "value": 0,
-                "title": "Disk Space",
-                "description": f"Error: {str(e)[:50]}",
-            }
-
-        # API Health
-        try:
-            from django.urls import get_resolver
-            resolver = get_resolver()
-            url_patterns = list(resolver.url_patterns)
-
-            metrics["api"] = {
-                "value": 100,
-                "title": "REST API",
-                "description": f"{len(url_patterns)} URL patterns",
-            }
-        except Exception:
-            metrics["api"] = {
-                "value": 50,
-                "title": "REST API",
-                "description": "Unable to count URLs",
-            }
-
-        return metrics
-
-
-@register_component
-class RecentUsersComponent(BaseComponent):
-    """
-    Recent users table component.
-
-    Provides formatted table data for displaying recent user registrations.
-    """
-
-    def get_context_data(self, **kwargs):
-        """Prepare recent users table data."""
-        context = super().get_context_data(**kwargs)
-
-        from django.contrib.auth import get_user_model
-        User = get_user_model()
-
-        try:
-            recent_users = User.objects.order_by('-date_joined')[:10]
-
-            context.update({
-                "data": {
-                    "headers": ["Username", "Email", "Status", "Staff", "Joined"],
-                    "rows": [
-                        [
-                            user.username,
-                            user.email,
-                            "✅ Active" if user.is_active else "❌ Inactive",
-                            "🛡️ Yes" if user.is_staff else "—",
-                            user.date_joined.strftime('%Y-%m-%d %H:%M')
-                        ]
-                        for user in recent_users
-                    ]
-                }
-            })
-        except Exception:
-            context.update({
-                "data": {
-                    "headers": [],
-                    "rows": []
-                }
-            })
-
-        return context
-
-
-@register_component
-class ChartsComponent(BaseComponent):
-    """
-    Charts data component for analytics.
-
-    Provides chart data for user registrations and activity.
-    Supports time range filtering (7/30/90 days).
-    """
-
-    def get_context_data(self, **kwargs):
-        """Prepare charts data."""
-        context = super().get_context_data(**kwargs)
-
-        # Get time range from kwargs (default: 7 days)
-        days = kwargs.get('days', 7)
-
-        import json
-        from datetime import datetime, timedelta
-
-        from django.contrib.auth import get_user_model
-        from django.utils import timezone
-
-        User = get_user_model()
-
-        try:
-            # Get last N days
-            today = timezone.now().date()
-            dates = [(today - timedelta(days=i)).strftime('%Y-%m-%d')
-                     for i in range(days-1, -1, -1)]
-
-            # User registrations
-            registrations = []
-            for date_str in dates:
-                date_obj = datetime.strptime(date_str, '%Y-%m-%d').date()
-                count = User.objects.filter(date_joined__date=date_obj).count()
-                registrations.append(count)
-
-            # User activity (last login)
-            activity = []
-            for date_str in dates:
-                date_obj = datetime.strptime(date_str, '%Y-%m-%d').date()
-                count = User.objects.filter(
-                    last_login__date=date_obj
-                ).count() if hasattr(User, 'last_login') else 0
-                activity.append(count)
-
-            # Format labels
-            day_labels = [d.split('-')[2] for d in dates]
-
-            # Chart data structures
-            user_reg_data = {
-                'labels': day_labels,
-                'datasets': [{
-                    'label': 'New Users',
-                    'data': registrations,
-                    'backgroundColor': 'rgba(59, 130, 246, 0.5)',
-                    'borderColor': 'rgb(59, 130, 246)',
-                    'borderWidth': 2,
-                }]
-            }
-
-            user_activity_data = {
-                'labels': day_labels,
-                'datasets': [{
-                    'label': 'Active Users',
-                    'data': activity,
-                    'backgroundColor': 'rgba(34, 197, 94, 0.5)',
-                    'borderColor': 'rgb(34, 197, 94)',
-                    'borderWidth': 2,
-                }]
-            }
-
-            context.update({
-                "data": {
-                    "registrations": json.dumps(user_reg_data),
-                    "activity": json.dumps(user_activity_data),
-                }
-            })
-        except Exception:
-            context.update({
-                "data": {}
-            })
-
-        return context
-
-
-@register_component
-class ActivityTrackerComponent(BaseComponent):
-    """
-    Activity tracker component for GitHub-style heatmap.
-
-    Provides 365 days of user activity data with level indicators.
-    """
-
-    def get_context_data(self, **kwargs):
-        """Prepare activity tracker data."""
-        context = super().get_context_data(**kwargs)
-
-        from datetime import timedelta
-
-        from django.contrib.auth import get_user_model
-        from django.utils import timezone
-
-        User = get_user_model()
-
-        try:
-            today = timezone.now().date()
-            activity_data = []
-
-            for days_ago in range(364, -1, -1):  # 365 days
-                date = today - timedelta(days=days_ago)
-
-                # Count registrations
-                registrations = User.objects.filter(
-                    date_joined__date=date
-                ).count()
-
-                # Count logins
-                logins = 0
-                if hasattr(User, 'last_login'):
-                    logins = User.objects.filter(
-                        last_login__date=date
-                    ).count()
-
-                total_activity = registrations + logins
-
-                activity_data.append({
-                    'date': date.isoformat(),
-                    'count': total_activity,
-                    'level': self._get_activity_level(total_activity),
-                })
-
-            context.update({
-                "data": activity_data
-            })
-        except Exception:
-            context.update({
-                "data": []
-            })
-
-        return context
-
-    def _get_activity_level(self, count: int) -> int:
-        """Convert activity count to level (0-4) for heatmap colors."""
-        if count == 0:
-            return 0
-        elif count <= 2:
-            return 1
-        elif count <= 5:
-            return 2
-        elif count <= 10:
-            return 3
-        else:
-            return 4

django_cfg/modules/django_dashboard/debug.py

@@ -1,174 +0,0 @@
-"""
-Debug utilities for dashboard rendering.
-
-Saves rendered HTML to disk for inspection and comparison.
-"""
-
-import json
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict, Optional
-
-
-class DashboardDebugger:
-    """Save dashboard renders for debugging."""
-
-    def __init__(self, output_dir: Optional[Path] = None):
-        """
-        Initialize debugger.
-
-        Args:
-            output_dir: Directory to save renders (default: django_cfg/debug/dashboard/)
-        """
-        if output_dir is None:
-            # Use django_cfg package directory
-            django_cfg_root = Path(__file__).parent.parent
-            output_dir = django_cfg_root / 'debug' / 'dashboard'
-
-        self.output_dir = Path(output_dir)
-        self.output_dir.mkdir(parents=True, exist_ok=True)
-
-    def save_render(
-        self,
-        html: str,
-        name: str = 'dashboard',
-        context: Optional[Dict[str, Any]] = None,
-        metadata: Optional[Dict[str, Any]] = None
-    ) -> Path:
-        """
-        Save rendered HTML with metadata.
-
-        Args:
-            html: Rendered HTML content
-            name: Base name for files
-            context: Template context data
-            metadata: Additional metadata
-
-        Returns:
-            Path to saved HTML file
-        """
-        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-        base_name = f"{name}_{timestamp}"
-
-        # Save HTML
-        html_path = self.output_dir / f"{base_name}.html"
-        html_path.write_text(html, encoding='utf-8')
-
-        # Save context as JSON
-        if context:
-            context_path = self.output_dir / f"{base_name}_context.json"
-            # Convert context to JSON-serializable format
-            serializable_context = self._make_serializable(context)
-            context_path.write_text(
-                json.dumps(serializable_context, indent=2, ensure_ascii=False),
-                encoding='utf-8'
-            )
-
-        # Save metadata
-        meta = {
-            'timestamp': timestamp,
-            'name': name,
-            'html_size': len(html),
-            'html_lines': html.count('\n'),
-        }
-
-        if metadata:
-            meta.update(metadata)
-
-        meta_path = self.output_dir / f"{base_name}_meta.json"
-        meta_path.write_text(
-            json.dumps(meta, indent=2, ensure_ascii=False),
-            encoding='utf-8'
-        )
-
-        print(f"✅ Saved dashboard render: {html_path}")
-        print(f"   Context: {context_path if context else 'N/A'}")
-        print(f"   Metadata: {meta_path}")
-
-        return html_path
-
-    def _make_serializable(self, obj: Any) -> Any:
-        """Convert object to JSON-serializable format."""
-        if isinstance(obj, dict):
-            return {k: self._make_serializable(v) for k, v in obj.items()}
-        elif isinstance(obj, (list, tuple)):
-            return [self._make_serializable(item) for item in obj]
-        elif isinstance(obj, (str, int, float, bool, type(None))):
-            return obj
-        else:
-            # For non-serializable objects, use string representation
-            return str(obj)
-
-    def save_section_render(
-        self,
-        section_name: str,
-        html: str,
-        section_data: Optional[Dict[str, Any]] = None
-    ) -> Path:
-        """
-        Save individual section render.
-
-        Args:
-            section_name: Name of section (overview, stats, etc.)
-            html: Rendered HTML
-            section_data: Section-specific data
-
-        Returns:
-            Path to saved file
-        """
-        return self.save_render(
-            html=html,
-            name=f"section_{section_name}",
-            context=section_data,
-            metadata={'section': section_name}
-        )
-
-    def compare_with_archive(self, current_html: str, archive_path: Path) -> Dict[str, Any]:
-        """
-        Compare current render with archived version.
-
-        Args:
-            current_html: Current rendered HTML
-            archive_path: Path to archived HTML
-
-        Returns:
-            Comparison results
-        """
-        if not archive_path.exists():
-            return {
-                'error': f"Archive not found: {archive_path}"
-            }
-
-        archive_html = archive_path.read_text(encoding='utf-8')
-
-        return {
-            'current_size': len(current_html),
-            'archive_size': len(archive_html),
-            'size_diff': len(current_html) - len(archive_html),
-            'current_lines': current_html.count('\n'),
-            'archive_lines': archive_html.count('\n'),
-            'lines_diff': current_html.count('\n') - archive_html.count('\n'),
-            'identical': current_html == archive_html,
-        }
-
-
-# Global instance
-_debugger: Optional[DashboardDebugger] = None
-
-
-def get_debugger() -> DashboardDebugger:
-    """Get or create global debugger instance."""
-    global _debugger
-    if _debugger is None:
-        _debugger = DashboardDebugger()
-    return _debugger
-
-
-def save_dashboard_render(html: str, **kwargs) -> Path:
-    """Convenience function to save dashboard render."""
-    return get_debugger().save_render(html, **kwargs)
-
-
-def save_section_render(section_name: str, html: str, **kwargs) -> Path:
-    """Convenience function to save section render."""
-    return get_debugger().save_section_render(section_name, html, **kwargs)