django-cfg 1.4.48__py3-none-any.whl → 1.5.7__py3-none-any.whl

django_cfg/modules/django_admin/utils/badges/status_badges.py

@@ -0,0 +1,171 @@
+"""
+Badge utilities with Material Icons.
+"""
+
+import logging
+from typing import Optional, Union
+
+from django.contrib.humanize.templatetags.humanize import intcomma
+from django.utils.html import escape, format_html
+from django.utils.safestring import SafeString
+
+from ...icons import Icons
+from ...models.badge_models import StatusBadgeConfig
+from ...models.base import BadgeVariant
+
+logger = logging.getLogger(__name__)
+
+
+class StatusBadge:
+    """Status badge utilities."""
+
+    # Status mappings
+    STATUS_MAPPINGS = {
+        'active': BadgeVariant.SUCCESS,
+        'success': BadgeVariant.SUCCESS,
+        'completed': BadgeVariant.SUCCESS,
+        'pending': BadgeVariant.WARNING,
+        'processing': BadgeVariant.WARNING,
+        'failed': BadgeVariant.DANGER,
+        'error': BadgeVariant.DANGER,
+        'cancelled': BadgeVariant.DANGER,
+        'inactive': BadgeVariant.SECONDARY,
+    }
+
+    # Variant classes with semantic colors
+    VARIANT_CLASSES = {
+        BadgeVariant.SUCCESS: 'bg-success-100 text-success-800 dark:bg-success-900 dark:text-success-200',
+        BadgeVariant.WARNING: 'bg-warning-100 text-warning-800 dark:bg-warning-900 dark:text-warning-200',
+        BadgeVariant.DANGER: 'bg-danger-100 text-danger-800 dark:bg-danger-900 dark:text-danger-200',
+        BadgeVariant.INFO: 'bg-info-100 text-info-800 dark:bg-info-900 dark:text-info-200',
+        BadgeVariant.PRIMARY: 'bg-primary-100 text-primary-800 dark:bg-primary-900 dark:text-primary-200',
+        BadgeVariant.SECONDARY: 'bg-base-100 text-font-default-light dark:bg-base-800 dark:text-font-default-dark',
+    }
+
+    @classmethod
+    def auto(cls, status: str, config: Optional[StatusBadgeConfig] = None) -> SafeString:
+        """Auto status badge with color mapping."""
+        config = config or StatusBadgeConfig()
+
+        if not status:
+            return format_html('<span class="text-font-subtle-light dark:text-font-subtle-dark">—</span>')
+
+        # Determine variant
+        status_lower = status.lower().replace('_', '').replace('-', '')
+        variant = BadgeVariant.INFO
+
+        for keyword, mapped_variant in cls.STATUS_MAPPINGS.items():
+            if keyword in status_lower:
+                variant = mapped_variant
+                break
+
+        # Use custom mapping if provided
+        if config.custom_mappings and status in config.custom_mappings:
+            variant_str = config.custom_mappings[status]
+            try:
+                variant = BadgeVariant(variant_str)
+            except ValueError:
+                pass
+
+        return cls.create(status.replace('_', ' ').title(), variant, config)
+
+    @classmethod
+    def create(cls, text: str, variant: Union[BadgeVariant, str] = BadgeVariant.INFO,
+              config: Optional[StatusBadgeConfig] = None, icon: Optional[str] = None) -> SafeString:
+        """Create custom badge."""
+        config = config or StatusBadgeConfig()
+
+        if isinstance(variant, str):
+            try:
+                variant = BadgeVariant(variant)
+            except ValueError:
+                variant = BadgeVariant.INFO
+
+        css_classes = cls.VARIANT_CLASSES.get(variant, cls.VARIANT_CLASSES[BadgeVariant.INFO])
+
+        if config.css_classes:
+            css_classes += ' ' + ' '.join(config.css_classes)
+
+        # Icon with Material Icons integration
+        icon_html = ""
+        if icon or (config.show_icons and config.icon):
+            icon_to_use = icon or config.icon
+            if icon_to_use:
+                # Use custom icon
+                icon_html = format_html('<span class="material-symbols-outlined text-xs mr-1">{}</span>', icon_to_use)
+            else:
+                # Auto-detect icon based on variant
+                icon_map = {
+                    BadgeVariant.SUCCESS: Icons.CHECK_CIRCLE,
+                    BadgeVariant.WARNING: Icons.WARNING,
+                    BadgeVariant.DANGER: Icons.ERROR,
+                    BadgeVariant.INFO: Icons.INFO,
+                    BadgeVariant.PRIMARY: Icons.STAR,
+                    BadgeVariant.SECONDARY: Icons.INFO,
+                }
+                icon_name = icon_map.get(variant, Icons.INFO)
+                icon_html = format_html('<span class="material-symbols-outlined text-xs mr-1">{}</span>', icon_name)
+
+        return format_html(
+            '<span class="inline-flex items-center rounded-full px-2.5 py-0.5 text-xs font-medium {}">'
+            '{}{}'
+            '</span>',
+            css_classes, icon_html, escape(text)
+        )
+
+
+class ProgressBadge:
+    """Progress badge utilities."""
+
+    @classmethod
+    def percentage(cls, percentage: Union[int, float]) -> SafeString:
+        """Progress badge with percentage."""
+        percentage = max(0, min(100, float(percentage)))
+
+        if percentage >= 100:
+            variant = BadgeVariant.SUCCESS
+        elif percentage >= 75:
+            variant = BadgeVariant.INFO
+        elif percentage >= 50:
+            variant = BadgeVariant.WARNING
+        else:
+            variant = BadgeVariant.SECONDARY
+
+        return StatusBadge.create(f"{percentage:.0f}%", variant)
+
+
+class CounterBadge:
+    """Counter badge utilities."""
+
+    @classmethod
+    def simple(cls, count: int, label: str = None, icon: Optional[str] = None,
+               variant: Optional[Union[BadgeVariant, str]] = None) -> SafeString:
+        """
+        Simple counter badge with optional icon.
+
+        Args:
+            count: The number to display
+            label: Optional label to append (e.g., "links", "items")
+            icon: Optional Material Icon name
+            variant: Optional variant to override auto color selection
+        """
+        # Auto-select variant based on count if not provided
+        if variant is None:
+            if count == 0:
+                variant = BadgeVariant.SECONDARY
+            elif count < 10:
+                variant = BadgeVariant.INFO
+            elif count < 100:
+                variant = BadgeVariant.WARNING
+            else:
+                variant = BadgeVariant.SUCCESS
+
+        # Format with humanize for large numbers
+        if count >= 1000:
+            count_text = intcomma(count)
+        else:
+            count_text = str(count)
+
+        display_text = f"{count_text} {label}" if label else count_text
+
+        return StatusBadge.create(display_text, variant, icon=icon)

django_cfg/modules/django_admin/utils/displays/__init__.py

@@ -0,0 +1,13 @@
+"""
+Display utilities for Django Admin.
+
+Provides UserDisplay, MoneyDisplay, and DateTimeDisplay classes.
+"""
+
+from .data_displays import DateTimeDisplay, MoneyDisplay, UserDisplay
+
+__all__ = [
+    "UserDisplay",
+    "MoneyDisplay",
+    "DateTimeDisplay",
+]

django_cfg/modules/django_admin/utils/displays/data_displays.py

@@ -0,0 +1,203 @@
+"""
+Display utilities with humanize integration.
+"""
+
+import logging
+from datetime import datetime
+from decimal import Decimal
+from typing import Any, List, Optional, Union
+
+from django.contrib.humanize.templatetags.humanize import naturaltime
+from django.utils import timezone
+from django.utils.html import escape, format_html
+from django.utils.safestring import SafeString
+
+from ...icons import Icons
+from ...models.display_models import DateTimeDisplayConfig, MoneyDisplayConfig, UserDisplayConfig
+
+logger = logging.getLogger(__name__)
+
+
+class UserDisplay:
+    """User display utilities."""
+
+    @classmethod
+    def with_avatar(cls, user: Any, config: Optional[UserDisplayConfig] = None) -> List[str]:
+        """Display user with avatar for @display(header=True)."""
+        config = config or UserDisplayConfig()
+
+        if not user:
+            return ["No user", "", "", {}]
+
+        name = getattr(user, 'get_full_name', lambda: '')() or getattr(user, 'username', 'Unknown')
+        email = getattr(user, 'email', '') if config.show_email else ''
+
+        # Generate initials
+        name_parts = name.split()
+        if len(name_parts) >= 2:
+            initials = f"{name_parts[0][0]}{name_parts[1][0]}".upper()
+        elif name:
+            initials = name[0].upper()
+        else:
+            initials = "U"
+
+        avatar_data = {"size": config.avatar_size, "initials": initials, "show": config.show_avatar}
+
+        return [name, email, initials, avatar_data]
+
+    @classmethod
+    def simple(cls, user: Any, config: Optional[UserDisplayConfig] = None) -> SafeString:
+        """Simple user display."""
+        config = config or UserDisplayConfig()
+
+        if not user:
+            return format_html('<span class="text-font-subtle-light dark:text-font-subtle-dark">No user</span>')
+
+        name = getattr(user, 'get_full_name', lambda: '')() or getattr(user, 'username', 'Unknown')
+        html = format_html('<span class="font-medium">{}</span>', escape(name))
+
+        if config.show_email:
+            email = getattr(user, 'email', '')
+            if email:
+                html = format_html('{}<br><span class="text-xs text-font-subtle-light dark:text-font-subtle-dark">{}</span>', html, escape(email))
+
+        return html
+
+
+class MoneyDisplay:
+    """Money display utilities."""
+
+    @classmethod
+    def amount(cls, amount: Union[Decimal, float, int], config: Optional[MoneyDisplayConfig] = None) -> SafeString:
+        """Format money amount with smart formatting."""
+        config = config or MoneyDisplayConfig()
+
+        if amount is None:
+            return format_html('<span class="text-font-subtle-light dark:text-font-subtle-dark">—</span>')
+
+        amount = Decimal(str(amount))
+
+        # Smart decimal places for rates or auto-adjustment
+        decimal_places = config.decimal_places
+        if config.smart_decimal_places or config.rate_mode:
+            if amount >= 1000:
+                decimal_places = 0  # 1,234 (whole numbers for large amounts)
+            elif amount >= 100:
+                decimal_places = 1  # 123.4
+            elif amount >= 10:
+                decimal_places = 2  # 12.34
+            elif amount >= 1:
+                decimal_places = 3  # 1.234
+            elif amount >= 0.01:
+                decimal_places = 4  # 0.1234
+            else:
+                decimal_places = 8  # 0.00001234 (for very small amounts)
+
+        # Currency symbols
+        symbols = {'USD': '$', 'EUR': '€', 'GBP': '£', 'JPY': '¥', 'BTC': '₿', 'ETH': 'Ξ'}
+        symbol = symbols.get(config.currency, config.currency) if config.show_currency_symbol else ""
+
+        # Format with appropriate decimal places
+        if config.thousand_separator:
+            if decimal_places == 0:
+                formatted_amount = f"{amount:,.0f}"
+            else:
+                formatted_amount = f"{amount:,.{decimal_places}f}"
+        else:
+            formatted_amount = f"{amount:.{decimal_places}f}"
+
+        # Special formatting for rate mode
+        if config.rate_mode:
+            # For rates, show number + small currency label instead of symbol
+            return format_html(
+                '<span class="font-mono text-sm">{} <span class="text-font-subtle-light dark:text-font-subtle-dark text-xs">{}</span></span>',
+                formatted_amount,
+                config.currency
+            )
+
+        # Color coding for regular amounts
+        if amount < 0:
+            color_class = "text-red-600 dark:text-red-400"
+        elif amount == 0:
+            color_class = "text-font-default-light dark:text-font-default-dark"
+        else:
+            color_class = "text-green-600 dark:text-green-400"
+
+        # Show sign
+        sign = "+" if config.show_sign and amount > 0 else ""
+
+        return format_html('<span class="font-mono {}">{}{}{}</span>', color_class, sign, symbol, formatted_amount)
+
+    @classmethod
+    def with_breakdown(cls, main_amount: Union[Decimal, float, int], breakdown_items: List[dict] = None,
+                      config: Optional[MoneyDisplayConfig] = None) -> SafeString:
+        """Display with breakdown."""
+        config = config or MoneyDisplayConfig()
+
+        html = format_html('<div class="text-right">')
+        html += cls.amount(main_amount, config)
+
+        if breakdown_items:
+            for item in breakdown_items:
+                label = item.get('label', 'Item')
+                amount = item.get('amount', 0)
+                color = item.get('color', 'secondary')
+
+                color_classes = {
+                    'success': 'text-green-600 dark:text-green-400',
+                    'warning': 'text-yellow-600 dark:text-yellow-400',
+                    'danger': 'text-red-600 dark:text-red-400',
+                    'secondary': 'text-font-subtle-light dark:text-font-subtle-dark'
+                }
+
+                color_class = color_classes.get(color, 'text-font-subtle-light dark:text-font-subtle-dark')
+                html += format_html('<div class="text-xs {}">{}: {}</div>', color_class, escape(label), cls.amount(amount, config))
+
+        html += format_html('</div>')
+        return html
+
+
+class DateTimeDisplay:
+    """DateTime display utilities."""
+
+    @classmethod
+    def relative(cls, dt: datetime, config: Optional[DateTimeDisplayConfig] = None) -> SafeString:
+        """Display with relative time."""
+        config = config or DateTimeDisplayConfig()
+
+        if not dt:
+            return format_html('<span class="text-font-subtle-light dark:text-font-subtle-dark">—</span>')
+
+        absolute_time = dt.strftime(config.datetime_format)
+        relative_time = naturaltime(dt)
+
+        if config.show_relative:
+            return format_html(
+                '<div class="text-xs"><div class="font-medium">{}</div><div class="text-font-subtle-light dark:text-font-subtle-dark">{}</div></div>',
+                escape(absolute_time), escape(relative_time)
+            )
+        else:
+            return format_html('<span class="text-sm">{}</span>', escape(absolute_time))
+
+    @classmethod
+    def compact(cls, dt: datetime, config: Optional[DateTimeDisplayConfig] = None) -> SafeString:
+        """Compact datetime display."""
+        config = config or DateTimeDisplayConfig()
+
+        if not dt:
+            return format_html('<span class="text-font-subtle-light dark:text-font-subtle-dark">—</span>')
+
+        now = timezone.now()
+        diff = now - dt
+
+        if diff.days < 1:
+            display_text = naturaltime(dt)
+        elif diff.days < 7:
+            display_text = dt.strftime('%a %H:%M')
+        else:
+            display_text = dt.strftime('%m/%d/%y')
+
+        return format_html(
+            '<span class="text-xs text-font-default-light dark:text-font-default-dark" title="{}">{}</span>',
+            escape(dt.strftime(config.datetime_format)), escape(display_text)
+        )

django_cfg/modules/django_admin/utils/html/__init__.py

@@ -0,0 +1,26 @@
+"""
+HTML builder module - organized and modular.
+
+Exports all HTML building classes for easy access.
+"""
+
+from .badges import BadgeElements
+from .base import BaseElements
+from .code import CodeElements
+from .composition import CompositionElements
+from .formatting import FormattingElements
+from .keyvalue import KeyValueElements
+from .markdown_integration import MarkdownIntegration
+from .progress import ProgressElements
+
+__all__ = [
+    # Core elements
+    "BaseElements",
+    "CodeElements",
+    "BadgeElements",
+    "CompositionElements",
+    "FormattingElements",
+    "KeyValueElements",
+    "ProgressElements",
+    "MarkdownIntegration",
+]

django_cfg/modules/django_admin/utils/html/badges.py

@@ -0,0 +1,55 @@
+"""
+Badge elements for Django Admin.
+
+Provides badge rendering with variants and icons.
+"""
+
+from typing import Optional
+
+from django.utils.html import escape, format_html
+from django.utils.safestring import SafeString
+
+
+class BadgeElements:
+    """Badge display elements."""
+
+    @staticmethod
+    def badge(text: any, variant: str = "primary", icon: Optional[str] = None) -> SafeString:
+        """
+        Render badge with optional icon.
+
+        Args:
+            text: Badge text
+            variant: primary, success, warning, danger, info, secondary
+            icon: Optional Material Icon
+
+        Usage:
+            html.badge("Active", variant="success", icon=Icons.CHECK_CIRCLE)
+        """
+        variant_classes = {
+            'success': 'bg-success-100 text-success-800 dark:bg-success-900 dark:text-success-200',
+            'warning': 'bg-warning-100 text-warning-800 dark:bg-warning-900 dark:text-warning-200',
+            'danger': 'bg-danger-100 text-danger-800 dark:bg-danger-900 dark:text-danger-200',
+            'info': 'bg-info-100 text-info-800 dark:bg-info-900 dark:text-info-200',
+            'primary': 'bg-primary-100 text-primary-800 dark:bg-primary-900 dark:text-primary-200',
+            'secondary': 'bg-base-100 text-font-default-light dark:bg-base-800 dark:text-font-default-dark',
+        }
+
+        css_classes = variant_classes.get(variant, variant_classes['primary'])
+
+        icon_html = ""
+        if icon:
+            icon_html = format_html('<span class="material-symbols-outlined text-xs mr-1">{}</span>', icon)
+
+        # Check if text is already safe HTML (e.g., from self.html.number() or self.html.inline())
+        if isinstance(text, SafeString):
+            # Already safe, don't escape
+            text_html = text
+        else:
+            # Regular text, escape for safety
+            text_html = escape(str(text))
+
+        return format_html(
+            '<span class="inline-flex items-center rounded-full px-2.5 py-0.5 text-xs font-medium {}">{}{}</span>',
+            css_classes, icon_html, text_html
+        )

django_cfg/modules/django_admin/utils/html/base.py

@@ -0,0 +1,167 @@
+"""
+Basic HTML elements for Django Admin.
+
+Provides fundamental HTML building blocks: icons, spans, text, divs, links, and empty placeholders.
+"""
+
+from typing import Any, Optional
+
+from django.utils.html import escape, format_html
+from django.utils.safestring import SafeString
+
+
+class BaseElements:
+    """Basic HTML building blocks."""
+
+    @staticmethod
+    def icon(icon_name: str, size: str = "xs", css_class: str = "") -> SafeString:
+        """
+        Render Material Icon.
+
+        Args:
+            icon_name: Icon name from Icons class
+            size: xs, sm, base, lg, xl
+            css_class: Additional CSS classes
+        """
+        size_classes = {
+            'xs': 'text-xs',
+            'sm': 'text-sm',
+            'base': 'text-base',
+            'lg': 'text-lg',
+            'xl': 'text-xl'
+        }
+        size_class = size_classes.get(size, 'text-xs')
+        classes = f"material-symbols-outlined {size_class}"
+        if css_class:
+            classes += f" {css_class}"
+
+        return format_html('<span class="{}">{}</span>', classes, icon_name)
+
+    @staticmethod
+    def span(text: Any, css_class: str = "") -> SafeString:
+        """
+        Render text in span with optional CSS class.
+
+        Args:
+            text: Text to display
+            css_class: CSS classes
+        """
+        if css_class:
+            return format_html('<span class="{}">{}</span>', css_class, escape(str(text)))
+        return format_html('<span>{}</span>', escape(str(text)))
+
+    @staticmethod
+    def text(
+        content: Any,
+        variant: Optional[str] = None,
+        size: Optional[str] = None,
+        weight: Optional[str] = None,
+        muted: bool = False
+    ) -> SafeString:
+        """
+        Render styled text with semantic variants.
+
+        Args:
+            content: Text content (can be SafeString from other html methods)
+            variant: Color variant - 'success', 'warning', 'danger', 'info', 'primary'
+            size: Size - 'xs', 'sm', 'base', 'lg', 'xl', '2xl'
+            weight: Font weight - 'normal', 'medium', 'semibold', 'bold'
+            muted: Use muted/subtle color
+
+        Usage:
+            # Success text
+            html.text("$1,234.56", variant="success", size="lg")
+
+            # Muted small text
+            html.text("(12.5%)", muted=True, size="sm")
+
+            # Combined with other methods
+            total = html.number(1234.56, prefix="$")
+            html.text(total, variant="success", size="lg")
+
+        Returns:
+            SafeString with styled text
+        """
+        classes = []
+
+        # Variant colors
+        if variant:
+            variant_classes = {
+                'success': 'text-success-600 dark:text-success-400',
+                'warning': 'text-warning-600 dark:text-warning-400',
+                'danger': 'text-danger-600 dark:text-danger-400',
+                'info': 'text-info-600 dark:text-info-400',
+                'primary': 'text-primary-600 dark:text-primary-400',
+            }
+            classes.append(variant_classes.get(variant, ''))
+
+        # Muted
+        if muted:
+            classes.append('text-font-subtle-light dark:text-font-subtle-dark')
+
+        # Size
+        if size:
+            size_classes = {
+                'xs': 'text-xs',
+                'sm': 'text-sm',
+                'base': 'text-base',
+                'lg': 'text-lg',
+                'xl': 'text-xl',
+                '2xl': 'text-2xl',
+            }
+            classes.append(size_classes.get(size, ''))
+
+        # Weight
+        if weight:
+            weight_classes = {
+                'normal': 'font-normal',
+                'medium': 'font-medium',
+                'semibold': 'font-semibold',
+                'bold': 'font-bold',
+            }
+            classes.append(weight_classes.get(weight, ''))
+
+        css_class = ' '.join(filter(None, classes))
+
+        if css_class:
+            return format_html('<span class="{}">{}</span>', css_class, content)
+        return format_html('<span>{}</span>', content)
+
+    @staticmethod
+    def div(content: Any, css_class: str = "") -> SafeString:
+        """
+        Render content in div with optional CSS class.
+
+        Args:
+            content: Content to display (can be SafeString)
+            css_class: CSS classes
+        """
+        if css_class:
+            return format_html('<div class="{}">{}</div>', css_class, content)
+        return format_html('<div>{}</div>', content)
+
+    @staticmethod
+    def link(url: str, text: str, css_class: str = "", target: str = "") -> SafeString:
+        """
+        Render link.
+
+        Args:
+            url: URL
+            text: Link text
+            css_class: CSS classes
+            target: Target attribute (_blank, _self, etc)
+        """
+        if target:
+            return format_html(
+                '<a href="{}" class="{}" target="{}">{}</a>',
+                url, css_class, target, escape(text)
+            )
+        return format_html('<a href="{}" class="{}">{}</a>', url, css_class, escape(text))
+
+    @staticmethod
+    def empty(text: str = "—") -> SafeString:
+        """Render empty/placeholder value."""
+        return format_html(
+            '<span class="text-font-subtle-light dark:text-font-subtle-dark">{}</span>',
+            escape(text)
+        )