django-cfg 1.4.120__py3-none-any.whl → 1.5.2__py3-none-any.whl

django_cfg/modules/django_admin/config/background_task_config.py

@@ -18,7 +18,7 @@ class BackgroundTaskConfig(BaseModel):
         ```python
         background_config = BackgroundTaskConfig(
             enabled=True,
-            task_runner='rearq',
+            task_runner='django_rq',
             batch_size=100,
             timeout=300,
         )
@@ -35,9 +35,9 @@ class BackgroundTaskConfig(BaseModel):
         description="Enable background task processing"
     )
 
-    task_runner: Literal['rearq', 'celery', 'django_q', 'sync'] = Field(
-        'rearq',
-        description="Task runner to use for background operations"
+    task_runner: Literal['django_rq', 'sync'] = Field(
+        'sync',
+        description="Task runner to use for background operations (django_rq or sync)"
     )
 
     batch_size: int = Field(

django_cfg/modules/django_admin/utils/__init__.py

@@ -1,17 +1,46 @@
 """
-Display and badge utilities for Django Admin.
+Display and utility modules for Django Admin.
+
+Refactored structure with logical organization:
+- badges/ - Status badges, progress badges, counter badges
+- displays/ - User displays, money displays, datetime displays
+- html/ - HTML building utilities (organized by functionality)
+- markdown/ - Markdown rendering with Mermaid support
+- decorators.py - Admin field decorators
+- html_builder.py - Backward-compatible facade for self.html.* API
 """
 
+# Badges
 from .badges import CounterBadge, ProgressBadge, StatusBadge
+
+# Decorators
 from .decorators import (
     annotated_field,
     badge_field,
     computed_field,
     currency_field,
 )
+
+# Displays
 from .displays import DateTimeDisplay, MoneyDisplay, UserDisplay
+
+# HTML Builders (organized by functionality)
+from .html import (
+    BadgeElements,
+    BaseElements,
+    CodeElements,
+    CompositionElements,
+    FormattingElements,
+    KeyValueElements,
+    MarkdownIntegration,
+    ProgressElements,
+)
+
+# HtmlBuilder - Backward-compatible facade
 from .html_builder import HtmlBuilder
-from .markdown_renderer import MarkdownRenderer
+
+# Markdown
+from .markdown import MarkdownRenderer
 
 __all__ = [
     # Display utilities
@@ -22,7 +51,16 @@ __all__ = [
     "StatusBadge",
     "ProgressBadge",
     "CounterBadge",
-    # HTML Builder
+    # HTML Builders (modular)
+    "BaseElements",
+    "CodeElements",
+    "BadgeElements",
+    "CompositionElements",
+    "FormattingElements",
+    "KeyValueElements",
+    "ProgressElements",
+    "MarkdownIntegration",
+    # HTML Builder (backward-compatible facade)
     "HtmlBuilder",
     # Markdown Renderer
     "MarkdownRenderer",

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

@@ -0,0 +1,13 @@
+"""
+Badge utilities for Django Admin.
+
+Provides StatusBadge, ProgressBadge, and CounterBadge classes.
+"""
+
+from .status_badges import CounterBadge, ProgressBadge, StatusBadge
+
+__all__ = [
+    "StatusBadge",
+    "ProgressBadge",
+    "CounterBadge",
+]

django_cfg/modules/django_admin/utils/{badges.py → badges/status_badges.py}

@@ -9,9 +9,9 @@ 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
+from ...icons import Icons
+from ...models.badge_models import StatusBadgeConfig
+from ...models.base import BadgeVariant
 
 logger = logging.getLogger(__name__)
 

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.py → displays/data_displays.py}

@@ -12,8 +12,8 @@ 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
+from ...icons import Icons
+from ...models.display_models import DateTimeDisplayConfig, MoneyDisplayConfig, UserDisplayConfig
 
 logger = logging.getLogger(__name__)
 

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,47 @@
+"""
+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)
+
+        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(str(text))
+        )

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)
+        )

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

@@ -0,0 +1,87 @@
+"""
+Code display elements for Django Admin.
+
+Provides inline code and code block rendering with syntax highlighting support.
+"""
+
+from typing import Any, Optional
+
+from django.utils.html import escape, format_html
+from django.utils.safestring import SafeString
+
+
+class CodeElements:
+    """Code display elements."""
+
+    @staticmethod
+    def code(text: Any, css_class: str = "") -> SafeString:
+        """
+        Render inline code.
+
+        Args:
+            text: Code text
+            css_class: Additional CSS classes
+
+        Usage:
+            html.code("/path/to/file")
+            html.code("command --arg value")
+        """
+        base_classes = "font-mono text-xs bg-base-100 dark:bg-base-800 px-1.5 py-0.5 rounded"
+        classes = f"{base_classes} {css_class}".strip()
+
+        return format_html(
+            '<code class="{}">{}</code>',
+            classes,
+            escape(str(text))
+        )
+
+    @staticmethod
+    def code_block(
+        text: Any,
+        language: Optional[str] = None,
+        max_height: Optional[str] = None,
+        variant: str = "default"
+    ) -> SafeString:
+        """
+        Render code block with optional syntax highlighting and scrolling.
+
+        Args:
+            text: Code content
+            language: Programming language (json, python, bash, etc.) - for future syntax highlighting
+            max_height: Max height with scrolling (e.g., "400px", "20rem")
+            variant: Color variant - default, warning, danger, success, info
+
+        Usage:
+            html.code_block(json.dumps(data, indent=2), language="json")
+            html.code_block(stdout, max_height="400px")
+            html.code_block(stderr, max_height="400px", variant="warning")
+        """
+        # Variant-specific styles
+        variant_classes = {
+            'default': 'bg-base-50 dark:bg-base-900 border-base-200 dark:border-base-700',
+            'warning': 'bg-warning-50 dark:bg-warning-900/20 border-warning-200 dark:border-warning-700',
+            'danger': 'bg-danger-50 dark:bg-danger-900/20 border-danger-200 dark:border-danger-700',
+            'success': 'bg-success-50 dark:bg-success-900/20 border-success-200 dark:border-success-700',
+            'info': 'bg-info-50 dark:bg-info-900/20 border-info-200 dark:border-info-700',
+        }
+
+        variant_class = variant_classes.get(variant, variant_classes['default'])
+
+        # Base styles
+        base_classes = f"font-mono text-xs whitespace-pre-wrap break-words border rounded-md p-3 {variant_class}"
+
+        # Add max-height and overflow if specified
+        style = ""
+        if max_height:
+            style = f'style="max-height: {max_height}; overflow-y: auto;"'
+
+        # Add language class for potential syntax highlighting
+        lang_class = f"language-{language}" if language else ""
+
+        return format_html(
+            '<pre class="{} {}" {}><code>{}</code></pre>',
+            base_classes,
+            lang_class,
+            style,
+            escape(str(text))
+        )

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

@@ -0,0 +1,205 @@
+"""
+Composition elements for Django Admin.
+
+Provides methods for composing multiple elements together: inline, icon_text, header.
+"""
+
+from typing import Any, Optional, Union
+
+from django.utils.html import escape, format_html
+from django.utils.safestring import SafeString
+
+
+class CompositionElements:
+    """Element composition utilities."""
+
+    @staticmethod
+    def icon(icon_name: str, size: str = "xs", css_class: str = "") -> SafeString:
+        """
+        Render Material Icon (helper for internal use).
+
+        Args:
+            icon_name: Icon name
+            size: Icon size
+            css_class: Additional CSS classes
+        """
+        from .base import BaseElements
+        return BaseElements.icon(icon_name, size, css_class)
+
+    @staticmethod
+    def icon_text(icon_or_text: Union[str, Any], text: Any = None,
+                  icon_size: str = "xs", separator: str = " ") -> SafeString:
+        """
+        Render icon with text or emoji with text.
+
+        Args:
+            icon_or_text: Icon from Icons class, emoji, or text if text param is None
+            text: Optional text to display after icon
+            icon_size: Icon size (xs, sm, base, lg, xl)
+            separator: Separator between icon and text
+
+        Usage:
+            html.icon_text(Icons.EDIT, 5)  # Icon with number
+            html.icon_text("📝", 5)  # Emoji with number
+            html.icon_text("Active")  # Just text
+        """
+        if text is None:
+            # Just text
+            return format_html('<span>{}</span>', escape(str(icon_or_text)))
+
+        # Check if it's a Material Icon (from Icons class) or emoji
+        icon_str = str(icon_or_text)
+
+        # Detect if it's emoji by checking for non-ASCII characters
+        is_emoji = any(ord(c) > 127 for c in icon_str)
+
+        if is_emoji or icon_str in ['📝', '💬', '🛒', '👤', '📧', '🔔', '⚙️', '🔧', '📊', '🎯']:
+            # Emoji
+            icon_html = escape(icon_str)
+        else:
+            # Material Icon
+            icon_html = CompositionElements.icon(icon_str, size=icon_size)
+
+        # DON'T escape SafeString - it's already safe HTML!
+        from django.utils.safestring import SafeString
+        if isinstance(text, SafeString):
+            text_html = text
+        else:
+            text_html = escape(str(text))
+
+        return format_html('{}{}<span>{}</span>', icon_html, separator, text_html)
+
+    @staticmethod
+    def inline(*items, separator: str = " | ",
+               size: str = "small", css_class: str = "") -> SafeString:
+        """
+        Render items inline with separator.
+
+        Args:
+            *items: Variable number of SafeString/str items to join (filters out None values)
+            separator: Separator between items
+            size: small, medium, large
+            css_class: Additional CSS classes
+
+        Usage:
+            html.inline(
+                html.icon_text(Icons.EDIT, 5),
+                html.icon_text(Icons.CHAT, 10),
+                separator=" | "
+            )
+        """
+        # Filter out None values
+        filtered_items = [item for item in items if item is not None]
+
+        if not filtered_items:
+            return format_html('<span class="text-font-subtle-light dark:text-font-subtle-dark">—</span>')
+
+        size_classes = {
+            'small': 'text-xs',
+            'medium': 'text-sm',
+            'large': 'text-base'
+        }
+        size_class = size_classes.get(size, 'text-xs')
+
+        classes = size_class
+        if css_class:
+            classes += f" {css_class}"
+
+        # Convert items to strings, keeping SafeString as-is
+        from django.utils.safestring import SafeString, mark_safe
+        processed_items = []
+        for item in filtered_items:
+            if isinstance(item, (SafeString, str)):
+                processed_items.append(item)
+            else:
+                processed_items.append(escape(str(item)))
+
+        # Join with separator - str() doesn't lose SafeString when joined then mark_safe'd
+        joined = mark_safe(separator.join(str(item) for item in processed_items))
+
+        return format_html('<span class="{}">{}</span>', classes, joined)
+
+    @staticmethod
+    def header(
+        title: str,
+        subtitle: Optional[str] = None,
+        initials: Optional[str] = None,
+        avatar_variant: str = "primary"
+    ) -> SafeString:
+        """
+        Render header with avatar/initials, title and subtitle.
+
+        Creates a horizontal layout with circular avatar badge and text content.
+        Common pattern for displaying users, accounts, entities with identity.
+
+        Args:
+            title: Main title text
+            subtitle: Optional subtitle text (smaller, muted)
+            initials: Optional initials for avatar (e.g., "AB", "JD")
+            avatar_variant: Color variant for avatar badge (primary, success, info, etc.)
+
+        Usage:
+            # User with avatar
+            html.header(
+                title="John Doe",
+                subtitle="john@example.com • Admin",
+                initials="JD"
+            )
+
+            # Account with info
+            html.header(
+                title="Trading Account",
+                subtitle="Binance • SPOT • user@email.com",
+                initials="TA",
+                avatar_variant="success"
+            )
+
+            # Simple title only
+            html.header(title="Item Name")
+
+        Returns:
+            SafeString with header component HTML
+        """
+        # Avatar/initials badge
+        avatar_html = ""
+        if initials:
+            avatar_html = format_html(
+                '<span class="inline-flex items-center justify-center rounded-full w-8 h-8 text-xs font-semibold {} mr-3">{}</span>',
+                CompositionElements._get_avatar_classes(avatar_variant),
+                escape(initials)
+            )
+
+        # Title
+        title_html = format_html(
+            '<div class="font-medium text-sm text-font-default-light dark:text-font-default-dark">{}</div>',
+            escape(title)
+        )
+
+        # Subtitle
+        subtitle_html = ""
+        if subtitle:
+            subtitle_html = format_html(
+                '<div class="text-xs text-font-subtle-light dark:text-font-subtle-dark mt-0.5">{}</div>',
+                escape(subtitle)
+            )
+
+        # Combine
+        return format_html(
+            '<div class="flex items-center">{}<div>{}{}</div></div>',
+            avatar_html,
+            title_html,
+            subtitle_html
+        )
+
+    @staticmethod
+    def _get_avatar_classes(variant: str) -> str:
+        """Get CSS classes for avatar badge variant."""
+        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',
+        }
+        return variant_classes.get(variant, variant_classes['primary'])