django-cfg 1.1.82__py3-none-any.whl → 1.2.0__py3-none-any.whl

django_cfg/modules/django_unfold/models/dashboard.py

@@ -0,0 +1,206 @@
+"""
+Dashboard Components Models for Unfold
+
+Pydantic models for dashboard components like stat cards, health items, etc.
+"""
+
+from typing import List, Optional, Dict, Any, Literal
+from pydantic import BaseModel, Field, ConfigDict, computed_field
+
+
+class StatCard(BaseModel):
+    """Dashboard statistics card model."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    title: str = Field(..., description="Card title")
+    value: str = Field(..., description="Main value to display")
+    icon: str = Field(..., description="Material icon name")
+    change: Optional[str] = Field(None, description="Change indicator (e.g., '+12%')")
+    change_type: Literal["positive", "negative", "neutral"] = Field(default="neutral", description="Change type")
+    description: Optional[str] = Field(None, description="Additional description")
+    color: str = Field("primary", description="Card color theme")
+    
+    @computed_field
+    @property
+    def css_classes(self) -> Dict[str, str]:
+        """Get CSS classes for different states."""
+        return {
+            "positive": "text-emerald-600 bg-emerald-100 dark:bg-emerald-900/20 dark:text-emerald-400",
+            "negative": "text-red-600 bg-red-100 dark:bg-red-900/20 dark:text-red-400",
+            "neutral": "text-slate-600 bg-slate-100 dark:bg-slate-700 dark:text-slate-400"
+        }
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for Unfold dashboard widgets."""
+        return {
+            "title": self.title,
+            "value_template": self.value,
+            "icon": self.icon,
+            "color": self.color,
+            "change": self.change,
+            "change_type": self.change_type,
+            "description": self.description,
+        }
+
+
+class SystemHealthItem(BaseModel):
+    """System health status item."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    component: str = Field(..., description="Component name")
+    status: Literal["healthy", "warning", "error", "unknown"] = Field(..., description="Health status")
+    description: str = Field(..., description="Status description")
+    last_check: str = Field(..., description="Last check time")
+    health_percentage: Optional[int] = Field(None, description="Health percentage (0-100)")
+    
+    @computed_field
+    @property
+    def icon(self) -> str:
+        """Get icon based on component type."""
+        icons = {
+            "database": "storage",
+            "cache": "memory", 
+            "queue": "queue",
+            "storage": "folder",
+            "api": "api",
+        }
+        return icons.get(self.component.lower(), "info")
+    
+    @computed_field
+    @property
+    def status_icon(self) -> str:
+        """Get status icon."""
+        icons = {
+            "healthy": "check_circle",
+            "warning": "warning", 
+            "error": "error",
+            "unknown": "help"
+        }
+        return icons.get(self.status, "help")
+
+
+class QuickAction(BaseModel):
+    """Quick action button model."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    title: str = Field(..., description="Action title")
+    description: str = Field(..., description="Action description")
+    icon: str = Field(..., description="Material icon name")
+    link: str = Field(..., description="Action URL or URL name")
+    color: Literal["primary", "success", "warning", "danger", "secondary"] = Field(default="primary", description="Button color theme")
+    category: str = Field("general", description="Action category (admin, user, system)")
+
+    def get_resolved_url(self) -> str:
+        """
+        Resolve URL name to full URL if needed.
+
+        Returns:
+            Full URL string - either the original link if it's already a URL,
+            or the resolved URL if it's a URL name.
+        """
+        # If link starts with '/' or 'http', it's already a full URL
+        if self.link.startswith(("/", "http")):
+            return self.link
+
+        # Try to resolve as URL name
+        try:
+            from django.urls import reverse
+            from django.urls.exceptions import NoReverseMatch
+            return reverse(self.link)
+        except (NoReverseMatch, ImportError, Exception):
+            # If reverse fails, return the original link
+            return self.link
+
+    def model_dump(self, **kwargs) -> dict:
+        """Override model_dump to include resolved URL."""
+        data = super().model_dump(**kwargs)
+        # Replace link with resolved URL
+        data["link"] = self.get_resolved_url()
+        return data
+
+
+class DashboardWidget(BaseModel):
+    """Dashboard widget configuration."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+
+    title: str = Field(..., description="Widget title")
+    template: Optional[str] = Field(None, description="Custom template path")
+    callback: Optional[str] = Field(None, description="Callback function path")
+    width: int = Field(12, description="Widget width (1-12)")
+    order: int = Field(0, description="Widget order")
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for Unfold dashboard widgets."""
+        return {
+            "title": self.title,
+            "template": self.template,
+            "callback": self.callback,
+            "width": self.width,
+            "order": self.order,
+        }
+
+
+class StatsCardsWidget(BaseModel):
+    """Stats cards widget for dashboard."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    type: Literal["stats_cards"] = Field(default="stats_cards", description="Widget type")
+    title: str = Field(..., description="Widget title")
+    cards: List[StatCard] = Field(default_factory=list, description="Statistics cards")
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for Unfold dashboard widgets."""
+        return {
+            "type": self.type,
+            "title": self.title,
+            "cards": [card.to_dict() for card in self.cards],
+        }
+
+
+class ChartDataset(BaseModel):
+    """Chart dataset for dashboard charts."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+
+    label: str = Field(..., description="Dataset label")
+    data: List[int] = Field(default_factory=list, description="Data points")
+    backgroundColor: str = Field(..., description="Background color")
+    borderColor: str = Field(..., description="Border color")
+    tension: float = Field(0.4, description="Line tension")
+
+
+class ChartData(BaseModel):
+    """Chart data structure."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+
+    labels: List[str] = Field(default_factory=list, description="Chart labels")
+    datasets: List[ChartDataset] = Field(default_factory=list, description="Chart datasets")
+
+
+class DashboardData(BaseModel):
+    """Main dashboard data container."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    # Statistics cards
+    stat_cards: List[StatCard] = Field(default_factory=list, description="Dashboard statistics cards")
+    
+    # System health
+    system_health: List[SystemHealthItem] = Field(default_factory=list, description="System health items")
+    
+    # Quick actions
+    quick_actions: List[QuickAction] = Field(default_factory=list, description="Quick action buttons")
+    
+    # Additional data
+    last_updated: str = Field(..., description="Last update timestamp")
+    environment: str = Field("development", description="Current environment")
+    
+    @computed_field
+    @property
+    def total_users(self) -> int:
+        """Get total users from stat cards."""
+        for card in self.stat_cards:
+            if "user" in card.title.lower():
+                try:
+                    return int(card.value.replace(",", ""))
+                except (ValueError, AttributeError):
+                    pass
+        return 0

django_cfg/modules/django_unfold/models/dropdown.py

@@ -0,0 +1,40 @@
+"""
+Site Dropdown Models for Unfold Dashboard
+
+Pydantic models for site dropdown menu items.
+"""
+
+from typing import Union, Callable
+from pydantic import BaseModel, Field, ConfigDict, computed_field
+from ..utils import auto_resolve_url
+
+
+class SiteDropdownItem(BaseModel):
+    """Site dropdown menu item configuration with automatic URL resolution."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    title: str = Field(..., min_length=1, description="Menu item title")
+    icon: str = Field(..., min_length=1, description="Material icon name")
+    link: str = Field(..., min_length=1, description="Link URL or URL name")
+
+    @computed_field
+    @property
+    def resolved_link(self) -> Union[str, Callable]:
+        """Get the link resolved for Unfold (computed field to avoid recursion)."""
+        if self.link:
+            return auto_resolve_url(self.link)
+        return "#"
+
+    def get_link_for_unfold(self):
+        """Get the link in the format expected by Unfold."""
+        return self.resolved_link
+    
+    def to_dict(self) -> dict:
+        """Convert to dictionary for Unfold admin."""
+        return {
+            "icon": self.icon,
+            "title": self.title,
+            "link": self.get_link_for_unfold(),
+        }
+
+

django_cfg/modules/django_unfold/models/navigation.py

@@ -0,0 +1,73 @@
+"""
+Navigation Models for Unfold Dashboard
+
+Pydantic models for navigation items and sections.
+"""
+
+from typing import List, Optional, Union, Callable
+from pydantic import BaseModel, Field, ConfigDict, computed_field
+from enum import Enum
+from ..utils import auto_resolve_url
+
+
+class NavigationItemType(str, Enum):
+    """Navigation item types."""
+    LINK = "link"
+    SEPARATOR = "separator"
+    GROUP = "group"
+
+
+class NavigationItem(BaseModel):
+    """Single navigation item configuration with automatic URL resolution."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    title: str = Field(..., min_length=1, description="Navigation item title")
+    icon: Optional[str] = Field(None, description="Material icon name")
+    link: Optional[str] = Field(None, description="URL link or URL name")
+    badge: Optional[str] = Field(None, description="Badge callback function path")
+    permission: Optional[str] = Field(None, description="Permission callback function path")
+    type: NavigationItemType = Field(default=NavigationItemType.LINK, description="Item type")
+
+    @computed_field
+    @property
+    def resolved_link(self) -> Union[str, Callable]:
+        """Get the link resolved for Unfold (computed field to avoid recursion)."""
+        if self.link:
+            return auto_resolve_url(self.link)
+        return "#"
+
+    def get_link_for_unfold(self):
+        """Get the link in the format expected by Unfold."""
+        return self.resolved_link
+    
+    def to_dict(self) -> dict:
+        """Convert to dictionary for Unfold admin."""
+        return {
+            "title": self.title,
+            "icon": self.icon,
+            "link": self.get_link_for_unfold(),
+            "badge": self.badge,
+            "permission": self.permission,
+        }
+
+
+
+class NavigationSection(BaseModel):
+    """Navigation section configuration."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    title: str = Field(..., min_length=1, description="Section title")
+    separator: bool = Field(default=True, description="Show separator")
+    collapsible: bool = Field(default=True, description="Section is collapsible")
+    items: List[NavigationItem] = Field(default_factory=list, description="Navigation items")
+    
+    def to_dict(self) -> dict:
+        """Convert to dictionary for Unfold admin."""
+        return {
+            "title": self.title,
+            "separator": self.separator,
+            "collapsible": self.collapsible,
+            "items": [item.to_dict() for item in self.items],
+        }
+
+

django_cfg/modules/django_unfold/models/tabs.py

@@ -0,0 +1,25 @@
+"""
+Tab Configuration Models for Unfold Dashboard
+
+Pydantic models for tab configurations.
+"""
+
+from typing import List, Optional
+from pydantic import BaseModel, Field, ConfigDict
+
+
+class TabItem(BaseModel):
+    """Tab item configuration."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    title: str = Field(..., min_length=1, description="Tab title")
+    link: str = Field(..., min_length=1, description="Tab URL")
+    permission: Optional[str] = Field(None, description="Permission callback")
+
+
+class TabConfiguration(BaseModel):
+    """Tab configuration for admin models."""
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+    
+    models: List[str] = Field(..., min_items=1, description="Model names for tab")
+    items: List[TabItem] = Field(..., min_items=1, description="Tab items")

django_cfg/modules/{unfold → django_unfold}/system_monitor.py

@@ -12,10 +12,10 @@ from typing import Dict, Any, List, Optional
 from django.db import connections
 from django.utils import timezone
 from django.contrib.auth import get_user_model
-from .. import BaseModule
+from .. import BaseCfgModule
 
 
-class SystemMonitor(BaseModule):
+class SystemMonitor(BaseCfgModule):
     """
     System monitoring module for Unfold dashboard.
     

django_cfg/modules/django_unfold/utils.py

@@ -0,0 +1,140 @@
+"""
+Utility functions for Django Unfold integration.
+"""
+
+from typing import Callable, Union
+import logging
+from django.http import HttpRequest
+
+logger = logging.getLogger(__name__)
+
+
+def auto_resolve_url(url_name_or_path: str) -> Union[str, Callable[[HttpRequest], str]]:
+    """
+    Automatically convert URL names to resolver functions.
+    
+    If the string doesn't start with '/' or 'http', treat it as a URL name
+    and return a function that will resolve it at runtime.
+    
+    Args:
+        url_name_or_path: URL name (e.g., 'admin:app_model_changelist') or direct path
+        
+    Returns:
+        Direct URL string or callable that resolves URL name
+    """
+    if not url_name_or_path or url_name_or_path.startswith(("/", "http")):
+        # It's already a direct URL, return as is
+        return url_name_or_path
+    
+    # It's a URL name, create a resolver function
+    url_name = url_name_or_path
+    
+    def resolve_url(request: HttpRequest) -> str:
+        try:
+            from django.urls import reverse
+            from django.urls.exceptions import NoReverseMatch
+            resolved = reverse(url_name)
+            logger.debug(f"Auto-resolved URL: {url_name} -> {resolved}")
+            return resolved
+        except (NoReverseMatch, Exception) as e:
+            logger.warning(f"Could not resolve URL '{url_name}': {e}")
+            return url_name
+    
+    return resolve_url
+
+
+def get_link_for_unfold(link: Union[str, Callable]) -> Union[str, Callable]:
+    """
+    Get the link in the format expected by Unfold.
+    
+    Args:
+        link: Direct URL string or resolver function
+        
+    Returns:
+        Link in format expected by Unfold (string or callable)
+    """
+    if callable(link):
+        # It's a resolver function, Unfold will call it with request
+        return link
+    else:
+        # It's a direct URL
+        return link
+
+
+# Convenience functions for common admin URLs
+def admin_changelist(app_label: str, model_name: str) -> Callable[[HttpRequest], str]:
+    """Create URL resolver for admin changelist."""
+    return auto_resolve_url(f"admin:{app_label}_{model_name}_changelist")
+
+
+def admin_add(app_label: str, model_name: str) -> Callable[[HttpRequest], str]:
+    """Create URL resolver for admin add form."""
+    return auto_resolve_url(f"admin:{app_label}_{model_name}_add")
+
+
+def admin_change(app_label: str, model_name: str, obj_id: str = "0") -> Callable[[HttpRequest], str]:
+    """Create URL resolver for admin change form."""
+    return auto_resolve_url(f"admin:{app_label}_{model_name}_change/{obj_id}/")
+
+
+def admin_model_url(model_class, action: str = "changelist") -> Callable[[HttpRequest], str]:
+    """
+    Create URL resolver for any Django model admin action.
+    
+    Args:
+        model_class: Django model class
+        action: Admin action ('changelist', 'add', 'change', etc.)
+        
+    Returns:
+        URL resolver function
+    """
+    try:
+        app_label = model_class._meta.app_label
+        model_name = model_class._meta.model_name
+        return auto_resolve_url(f"admin:{app_label}_{model_name}_{action}")
+    except Exception:
+        # Fallback to admin index
+        return auto_resolve_url("admin:index")
+
+
+def user_admin_url() -> Callable[[HttpRequest], str]:
+    """Create URL resolver for current AUTH_USER_MODEL admin changelist."""
+    try:
+        from django.contrib.auth import get_user_model
+        User = get_user_model()
+        return admin_model_url(User, "changelist")
+    except Exception:
+        # Fallback to admin index
+        return auto_resolve_url("admin:index")
+
+
+def create_navigation_item(title: str, icon: str, model_class=None, url_name: str = None, direct_url: str = None):
+    """
+    Create NavigationItem with automatic URL resolution.
+    
+    Args:
+        title: Navigation item title
+        icon: Material icon name
+        model_class: Django model class (for admin URLs)
+        url_name: Django URL name
+        direct_url: Direct URL path
+        
+    Returns:
+        NavigationItem with proper URL resolution
+    """
+    from .models.navigation import NavigationItem
+    
+    if model_class:
+        # Use model admin changelist
+        link = admin_model_url(model_class, "changelist")
+    elif url_name:
+        # Use URL name
+        link = auto_resolve_url(url_name)
+    elif direct_url:
+        # Use direct URL
+        link = direct_url
+    else:
+        # Fallback
+        link = "#"
+    
+    return NavigationItem(title=title, icon=icon, link=link)

django_cfg/registry/__init__.py

@@ -0,0 +1,23 @@
+"""
+Django-CFG Import Registry
+
+Organized import system for django-cfg components.
+"""
+
+from .core import CORE_REGISTRY
+from .services import SERVICES_REGISTRY  
+from .third_party import THIRD_PARTY_REGISTRY
+from .modules import MODULES_REGISTRY
+from .exceptions import EXCEPTIONS_REGISTRY
+
+# Combine all registries
+DJANGO_CFG_REGISTRY = {
+    **CORE_REGISTRY,
+    **SERVICES_REGISTRY,
+    **THIRD_PARTY_REGISTRY,
+    **MODULES_REGISTRY,
+    **EXCEPTIONS_REGISTRY,
+}
+
+# Export all available names
+__all__ = list(DJANGO_CFG_REGISTRY.keys())

django_cfg/registry/core.py

@@ -0,0 +1,61 @@
+"""
+Core Django-CFG components registry.
+"""
+
+CORE_REGISTRY = {
+    # Core configuration
+    "DjangoConfig": ("django_cfg.core.config", "DjangoConfig"),
+    
+    # Core exceptions
+    "ConfigurationError": ("django_cfg.core.exceptions", "ConfigurationError"),
+    "ValidationError": ("django_cfg.core.exceptions", "ValidationError"),
+    "DatabaseError": ("django_cfg.core.exceptions", "DatabaseError"),
+    "CacheError": ("django_cfg.core.exceptions", "CacheError"),
+    "EnvironmentError": ("django_cfg.core.exceptions", "EnvironmentError"),
+    
+    # Core integration
+    "DjangoIntegration": ("django_cfg.core.integration", "DjangoIntegration"),
+    
+    # Database models
+    "DatabaseConfig": ("django_cfg.models.database", "DatabaseConfig"),
+    
+    # Cache models  
+    "CacheConfig": ("django_cfg.models.cache", "CacheConfig"),
+    
+    # Security models
+    "SecuritySettings": ("django_cfg.models.security", "SecuritySettings"),
+    
+    # Logging models
+    "LoggingConfig": ("django_cfg.models.logging", "LoggingConfig"),
+    
+    # Environment models
+    "EnvironmentConfig": ("django_cfg.models.environment", "EnvironmentConfig"),
+    
+    # Limits models
+    "LimitsConfig": ("django_cfg.models.limits", "LimitsConfig"),
+    
+    # JWT models
+    "JWTConfig": ("django_cfg.models.jwt", "JWTConfig"),
+    
+    # Task and queue models
+    "TaskConfig": ("django_cfg.models.tasks", "TaskConfig"),
+    "DramatiqConfig": ("django_cfg.models.tasks", "DramatiqConfig"),
+    
+    # Utils
+    "version_check": ("django_cfg.utils.version_check", "version_check"),
+    "toolkit": ("django_cfg.utils.toolkit", "toolkit"),
+    "ConfigToolkit": ("django_cfg.utils.toolkit", "ConfigToolkit"),
+    
+    # Routing
+    "DynamicRouter": ("django_cfg.routing.routers", "DynamicRouter"),
+    "health_callback": ("django_cfg.routing.callbacks", "health_callback"),
+    
+    # Health module
+    "HealthService": ("django_cfg.modules.django_health", "HealthService"),
+    
+    # Library configuration
+    "LIB_NAME": ("django_cfg.config", "LIB_NAME"),
+    "LIB_SITE_URL": ("django_cfg.config", "LIB_SITE_URL"),
+    "LIB_HEALTH_URL": ("django_cfg.config", "LIB_HEALTH_URL"),
+    "get_default_dropdown_items": ("django_cfg.config", "get_default_dropdown_items"),
+}

django_cfg/registry/exceptions.py

@@ -0,0 +1,11 @@
+"""
+Django-CFG exceptions registry.
+"""
+
+EXCEPTIONS_REGISTRY = {
+    # Core exceptions
+    "DjangoCfgException": ("django_cfg.core.exceptions", "DjangoCfgException"),
+    "ConfigurationError": ("django_cfg.core.exceptions", "ConfigurationError"),
+    "ValidationError": ("django_cfg.core.exceptions", "ValidationError"),
+    "EnvironmentError": ("django_cfg.core.exceptions", "EnvironmentError"),
+}

django_cfg/registry/modules.py

@@ -0,0 +1,12 @@
+"""
+Django-CFG modules and utilities registry.
+"""
+
+MODULES_REGISTRY = {
+    # URL integration
+    "add_django_cfg_urls": ("django_cfg.core.integration", "add_django_cfg_urls"),
+    "get_django_cfg_urls_info": ("django_cfg.core.integration", "get_django_cfg_urls_info"),
+    
+    # Configuration utilities
+    "set_current_config": ("django_cfg.core.config", "set_current_config"),
+}

django_cfg/registry/services.py

@@ -0,0 +1,26 @@
+"""
+Service integrations registry.
+"""
+
+SERVICES_REGISTRY = {
+    # Email services
+    "EmailConfig": ("django_cfg.models.services", "EmailConfig"),
+    "DjangoEmailService": ("django_cfg.modules.django_email", "DjangoEmailService"),
+    "send_email": ("django_cfg.modules.django_email", "send_email"),
+    "SendGridConfig": ("django_cfg.modules.django_twilio.models", "SendGridConfig"),
+    
+    # Telegram services
+    "TelegramConfig": ("django_cfg.models.services", "TelegramConfig"),
+    "DjangoTelegram": ("django_cfg.modules.django_telegram", "DjangoTelegram"),
+    "send_telegram_message": ("django_cfg.modules.django_telegram", "send_telegram_message"),
+    "send_telegram_photo": ("django_cfg.modules.django_telegram", "send_telegram_photo"),
+    
+    # Twilio services
+    "TwilioConfig": ("django_cfg.modules.django_twilio.models", "TwilioConfig"),
+    "TwilioVerifyConfig": ("django_cfg.modules.django_twilio.models", "TwilioVerifyConfig"),
+    "TwilioChannelType": ("django_cfg.modules.django_twilio.models", "TwilioChannelType"),
+    
+    # Logging services
+    "DjangoLogger": ("django_cfg.modules.django_logger", "DjangoLogger"),
+    "get_logger": ("django_cfg.modules.django_logger", "get_logger"),
+}