django-cfg 1.4.46__py3-none-any.whl → 1.5.181__py3-none-any.whl

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

@@ -0,0 +1,118 @@
+"""
+Status badges display utility.
+
+Renders multiple conditional status badges.
+"""
+
+from typing import Any, Dict, List, Optional
+
+from django.template.loader import render_to_string
+from django.utils.safestring import mark_safe
+
+
+# Badge color classes mapping
+BADGE_COLORS = {
+    'primary': 'bg-blue-100 text-blue-800 dark:bg-blue-900 dark:text-blue-300',
+    'secondary': 'bg-gray-100 text-gray-800 dark:bg-gray-700 dark:text-gray-300',
+    'success': 'bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-300',
+    'danger': 'bg-red-100 text-red-800 dark:bg-red-900 dark:text-red-300',
+    'warning': 'bg-yellow-100 text-yellow-800 dark:bg-yellow-900 dark:text-yellow-300',
+    'info': 'bg-cyan-100 text-cyan-800 dark:bg-cyan-900 dark:text-cyan-300',
+}
+
+
+class StatusBadgesDisplay:
+    """
+    Display utility for multiple conditional status badges.
+
+    Usage in admin:
+        StatusBadgesField(
+            name="status",
+            badge_rules=[
+                BadgeRule(condition_field="is_active", label="Active", variant="success"),
+                BadgeRule(condition_field="is_verified", label="Verified", variant="info"),
+            ]
+        )
+    """
+
+    @classmethod
+    def render(
+        cls,
+        badges: List[Dict[str, Any]],
+        config: Optional[Dict[str, Any]] = None,
+    ) -> str:
+        """
+        Render multiple status badges.
+
+        Args:
+            badges: List of badge dicts with label, color_class, icon
+            config: Configuration options
+
+        Returns:
+            HTML string with badges
+        """
+        config = config or {}
+
+        context = {
+            'badges': badges,
+            'separator': config.get('separator', ' '),
+            'empty_text': config.get('empty_text'),
+            'empty_color_class': BADGE_COLORS.get(
+                config.get('empty_variant', 'secondary'),
+                BADGE_COLORS['secondary']
+            ),
+        }
+
+        return render_to_string(
+            'django_admin/widgets/status_badges_display.html',
+            context
+        )
+
+    @classmethod
+    def from_field(
+        cls,
+        obj: Any,
+        field: str,
+        config: Optional[Dict[str, Any]] = None,
+    ) -> str:
+        """
+        Render status badges from model field.
+
+        Args:
+            obj: Model instance
+            field: Field name (used for validation)
+            config: Configuration options
+
+        Returns:
+            HTML string with badges
+        """
+        config = config or {}
+
+        # Validate field exists
+        if not hasattr(obj, field):
+            return mark_safe(
+                f'<span class="text-red-600 font-bold">'
+                f'StatusBadgesField Error: Field "{field}" not found</span>'
+            )
+
+        badge_rules = config.get('badge_rules', [])
+
+        # Check each rule and collect matching badges
+        badges = []
+        for rule in badge_rules:
+            condition_field = rule.get('condition_field')
+            condition_value = rule.get('condition_value', True)
+            label = rule.get('label', '')
+            variant = rule.get('variant', 'secondary')
+            icon = rule.get('icon')
+
+            # Check if condition matches
+            field_value = getattr(obj, condition_field, None)
+            if field_value == condition_value:
+                badges.append({
+                    'label': label,
+                    'color_class': BADGE_COLORS.get(variant, BADGE_COLORS['secondary']),
+                    'icon': icon,
+                })
+
+        return cls.render(badges, config)

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

@@ -0,0 +1,136 @@
+"""
+Text display utilities with truncation and styling.
+"""
+
+from typing import Any, Dict, Optional
+
+from django.utils.html import escape, format_html
+from django.utils.safestring import SafeString
+
+
+class TextDisplay:
+    """Text display with truncation, nowrap, and styling options."""
+
+    @classmethod
+    def from_field(cls, obj: Any, field_name: str, config: Dict[str, Any]) -> SafeString:
+        """
+        Render text field with configuration.
+
+        Config options:
+            truncate: int - Max characters to show (default: None = no truncation)
+            monospace: bool - Use monospace font (default: False)
+            nowrap: bool - Prevent line wrapping (default: True)
+            max_width: str - CSS max-width (default: "300px")
+            show_tooltip: bool - Show full text on hover (default: True when truncated)
+        """
+        value = getattr(obj, field_name, None)
+
+        if value is None or value == "":
+            return format_html(
+                '<span class="text-font-subtle-light dark:text-font-subtle-dark">—</span>'
+            )
+
+        text = str(value)
+        truncate = config.get('truncate')
+        monospace = config.get('monospace', False)
+        nowrap = config.get('nowrap', True)
+        max_width = config.get('max_width', '300px')
+        show_tooltip = config.get('show_tooltip', True)
+
+        # Truncate if needed
+        is_truncated = False
+        display_text = text
+        if truncate and len(text) > truncate:
+            display_text = text[:truncate] + "..."
+            is_truncated = True
+
+        # Build CSS classes
+        classes = ["text-sm"]
+        if monospace:
+            classes.append("font-mono")
+
+        # Link styling - use primary colors for clickable fields
+        is_link = config.get('is_link', False)
+        if is_link:
+            classes.append("text-primary-600")
+            classes.append("dark:text-primary-400")
+            classes.append("hover:text-primary-700")
+            classes.append("dark:hover:text-primary-500")
+
+        # Build inline styles
+        styles = []
+        if nowrap:
+            styles.append("white-space: nowrap")
+            styles.append("overflow: hidden")
+            styles.append("text-overflow: ellipsis")
+        if max_width:
+            styles.append(f"max-width: {max_width}")
+        styles.append("display: block")
+
+        class_str = " ".join(classes)
+        style_str = "; ".join(styles)
+
+        # Add tooltip for truncated text
+        if is_truncated and show_tooltip:
+            return format_html(
+                '<span class="{}" style="{}" title="{}">{}</span>',
+                class_str,
+                style_str,
+                escape(text),
+                escape(display_text)
+            )
+        else:
+            return format_html(
+                '<span class="{}" style="{}">{}</span>',
+                class_str,
+                style_str,
+                escape(display_text)
+            )
+
+    @classmethod
+    def truncated(
+        cls,
+        text: str,
+        max_length: int = 100,
+        monospace: bool = False,
+        max_width: str = "300px"
+    ) -> SafeString:
+        """
+        Simple truncated text display.
+
+        Args:
+            text: Text to display
+            max_length: Maximum characters
+            monospace: Use monospace font
+            max_width: CSS max-width value
+        """
+        if not text:
+            return format_html(
+                '<span class="text-font-subtle-light dark:text-font-subtle-dark">—</span>'
+            )
+
+        text = str(text)
+        is_truncated = len(text) > max_length
+        display_text = text[:max_length] + "..." if is_truncated else text
+
+        classes = ["text-sm"]
+        if monospace:
+            classes.append("font-mono")
+
+        style = f"white-space: nowrap; overflow: hidden; text-overflow: ellipsis; max-width: {max_width}; display: block"
+
+        if is_truncated:
+            return format_html(
+                '<span class="{}" style="{}" title="{}">{}</span>',
+                " ".join(classes),
+                style,
+                escape(text),
+                escape(display_text)
+            )
+        else:
+            return format_html(
+                '<span class="{}" style="{}">{}</span>',
+                " ".join(classes),
+                style,
+                escape(display_text)
+            )

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

@@ -0,0 +1,149 @@
+"""Video display utility with smart URL parsing."""
+
+import re
+from typing import Any, Dict, Optional
+
+from django.template.loader import render_to_string
+from django.utils.safestring import mark_safe
+
+
+class VideoDisplay:
+    """
+    Display video thumbnails with platform detection.
+
+    Supports:
+    - YouTube (youtube.com, youtu.be)
+    - Vimeo
+    - Direct video URLs (.mp4, .webm, etc.)
+    """
+
+    # Platform patterns
+    YOUTUBE_PATTERNS = [
+        r'(?:youtube\.com/watch\?v=|youtu\.be/|youtube\.com/embed/)([a-zA-Z0-9_-]{11})',
+        r'youtube\.com/shorts/([a-zA-Z0-9_-]{11})',
+    ]
+    VIMEO_PATTERN = r'vimeo\.com/(\d+)'
+
+    @classmethod
+    def parse_url(cls, url: str) -> Dict[str, Any]:
+        """
+        Parse video URL and extract platform info.
+
+        Returns:
+            Dict with keys: platform, video_id, thumbnail_url, embed_url
+        """
+        if not url:
+            return {'platform': None}
+
+        url = str(url)
+
+        # YouTube
+        for pattern in cls.YOUTUBE_PATTERNS:
+            match = re.search(pattern, url)
+            if match:
+                video_id = match.group(1)
+                return {
+                    'platform': 'youtube',
+                    'video_id': video_id,
+                    'thumbnail_url': f'https://img.youtube.com/vi/{video_id}/mqdefault.jpg',
+                    'embed_url': f'https://www.youtube.com/embed/{video_id}',
+                    'watch_url': f'https://www.youtube.com/watch?v={video_id}',
+                    'icon': 'smart_display',
+                }
+
+        # Vimeo
+        match = re.search(cls.VIMEO_PATTERN, url)
+        if match:
+            video_id = match.group(1)
+            return {
+                'platform': 'vimeo',
+                'video_id': video_id,
+                'thumbnail_url': None,  # Vimeo requires API for thumbnails
+                'embed_url': f'https://player.vimeo.com/video/{video_id}',
+                'watch_url': f'https://vimeo.com/{video_id}',
+                'icon': 'play_circle',
+            }
+
+        # Direct video URL
+        if any(url.lower().endswith(ext) for ext in ['.mp4', '.webm', '.ogg', '.mov']):
+            return {
+                'platform': 'direct',
+                'video_id': None,
+                'thumbnail_url': None,
+                'embed_url': url,
+                'watch_url': url,
+                'icon': 'videocam',
+            }
+
+        # Unknown - treat as direct link
+        return {
+            'platform': 'unknown',
+            'video_id': None,
+            'thumbnail_url': None,
+            'embed_url': None,
+            'watch_url': url,
+            'icon': 'link',
+        }
+
+    @classmethod
+    def render(cls, url: str, config: Optional[Dict[str, Any]] = None) -> str:
+        """
+        Render video thumbnail/player.
+
+        Args:
+            url: Video URL
+            config: Display configuration
+
+        Returns:
+            HTML string
+        """
+        config = config or {}
+        video_info = cls.parse_url(url)
+
+        if not video_info['platform']:
+            fallback = config.get('fallback_text', '—')
+            return fallback
+
+        context = {
+            'video_info': video_info,
+            'url': url,
+            'thumbnail_width': config.get('thumbnail_width', '200px'),
+            'thumbnail_height': config.get('thumbnail_height', '112px'),
+            'border_radius': config.get('border_radius', '8px'),
+            'show_inline': config.get('show_inline', False),
+            'show_platform': config.get('show_platform', True),
+        }
+
+        return render_to_string('django_admin/widgets/video_display.html', context)
+
+    @classmethod
+    def from_field(
+        cls,
+        obj: Any,
+        field: str,
+        config: Optional[Dict[str, Any]] = None,
+    ) -> str:
+        """
+        Render video from model field.
+
+        Args:
+            obj: Model instance
+            field: Field name
+            config: Configuration options
+
+        Returns:
+            HTML string
+        """
+        config = config or {}
+
+        # Get URL value
+        value = getattr(obj, field, None)
+        if callable(value):
+            url = value()
+        else:
+            url = value
+
+        if not url:
+            return config.get('empty_value', '—')
+
+        return cls.render(str(url), config)

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,198 @@
+"""
+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 = "",
+        icon: Optional[str] = None,
+        variant: Optional[str] = None
+    ) -> SafeString:
+        """
+        Render link.
+
+        Args:
+            url: URL
+            text: Link text
+            css_class: CSS classes
+            target: Target attribute (_blank, _self, etc)
+            icon: Icon name from Icons class
+            variant: Color variant
+        """
+        classes = []
+        if css_class:
+            classes.append(css_class)
+            
+        if variant:
+            variant_classes = {
+                'success': 'text-success-600 dark:text-success-400 hover:text-success-700',
+                'warning': 'text-warning-600 dark:text-warning-400 hover:text-warning-700',
+                'danger': 'text-danger-600 dark:text-danger-400 hover:text-danger-700',
+                'info': 'text-info-600 dark:text-info-400 hover:text-info-700',
+                'primary': 'text-primary-600 dark:text-primary-400 hover:text-primary-700',
+            }
+            classes.append(variant_classes.get(variant, ''))
+
+        final_css_class = " ".join(classes)
+        
+        content = escape(text)
+        if icon:
+            # Use BaseElements.icon directly
+            icon_html = BaseElements.icon(icon, size="sm", css_class="mr-1 align-text-bottom")
+            content = format_html("{} {}", icon_html, content)
+
+        if target:
+            return format_html(
+                '<a href="{}" class="{}" target="{}">{}</a>',
+                url, final_css_class, target, content
+            )
+        return format_html('<a href="{}" class="{}">{}</a>', url, final_css_class, content)
+
+    @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)
+        )