django-cfg 1.4.116__py3-none-any.whl → 1.5.14__py3-none-any.whl

django_cfg/modules/django_admin/utils/html_builder.py

@@ -1,419 +1,66 @@
 """
-Universal HTML builder for Django Admin display methods.
-"""
+HtmlBuilder - Facade class for backward compatibility.
 
-from pathlib import Path
-from typing import Any, List, Optional, Union
-import re
+This class provides the old `self.html.*` API by delegating to new modular components.
+All existing admin code using `self.html.badge()`, `self.html.inline()`, etc. will continue to work.
 
-from django.utils.html import escape, format_html
-from django.utils.safestring import SafeString
+New code should import and use the specific modules directly:
+    from django_cfg.modules.django_admin.utils import BaseElements, FormattingElements, etc.
+"""
 
-from ..icons import Icons
-from .markdown_renderer import MarkdownRenderer
+from .html import (
+    BadgeElements,
+    BaseElements,
+    CodeElements,
+    CompositionElements,
+    FormattingElements,
+    KeyValueElements,
+    MarkdownIntegration,
+    ProgressElements,
+)
 
 
 class HtmlBuilder:
     """
-    Universal HTML builder with Material Icons support and Markdown rendering.
-
-    Usage in admin methods:
-        def stats(self, obj):
-            return self.html.inline([
-                self.html.icon_text(Icons.EDIT, obj.posts_count),
-                self.html.icon_text(Icons.CHAT, obj.comments_count),
-            ])
+    Facade class that delegates to modular HTML utilities.
 
-        def documentation(self, obj):
-            return self.html.markdown_docs(obj.docs_path)
+    Provides backward compatibility for `self.html.*` API in admin classes.
     """
 
-    @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 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 = HtmlBuilder.icon(icon_str, size=icon_size)
-
-        return format_html('{}{}<span>{}</span>', icon_html, separator, escape(str(text)))
-
-    @staticmethod
-    def inline(items: List[Any], separator: str = " | ",
-               size: str = "small", css_class: str = "") -> SafeString:
-        """
-        Render items inline with separator.
-
-        Args:
-            items: List of SafeString/str items to join
-            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),
-            ])
-        """
-        if not 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 items:
-            if isinstance(item, (SafeString, str)):
-                processed_items.append(item)
-            else:
-                processed_items.append(escape(str(item)))
-
-        # Join with separator
-        joined = mark_safe(separator.join(str(item) for item in processed_items))
-
-        return format_html('<span class="{}">{}</span>', classes, joined)
-
-    @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 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 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))
-        )
-
-    @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)
-        )
-
-    @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))
-        )
-
-    @staticmethod
-    def markdown(
-        text: str,
-        css_class: str = "",
-        max_height: Optional[str] = None,
-        enable_plugins: bool = True
-    ) -> SafeString:
-        """
-        Render markdown text to beautifully styled HTML.
-
-        Delegates to MarkdownRenderer.render_markdown() for actual rendering.
-
-        Args:
-            text: Markdown content
-            css_class: Additional CSS classes
-            max_height: Max height with scrolling (e.g., "400px", "20rem")
-            enable_plugins: Enable mistune plugins (tables, strikethrough, etc.)
-
-        Usage:
-            # Simple markdown rendering
-            html.markdown("# Hello\\n\\nThis is **bold** text")
-
-            # With custom styling
-            html.markdown(obj.description, css_class="my-custom-class")
-
-            # With max height for long content
-            html.markdown(obj.documentation, max_height="500px")
-
-        Returns:
-            SafeString with rendered HTML
-        """
-        return MarkdownRenderer.render_markdown(
-            text=text,
-            css_class=css_class,
-            max_height=max_height,
-            enable_plugins=enable_plugins
-        )
-
-    @staticmethod
-    def uuid_short(uuid_value: Any, length: int = 6, show_tooltip: bool = True) -> SafeString:
-        """
-        Shorten UUID to first N characters with optional tooltip.
-
-        Args:
-            uuid_value: UUID string or UUID object
-            length: Number of characters to show (default: 6)
-            show_tooltip: Show full UUID on hover (default: True)
-
-        Usage:
-            html.uuid_short(obj.id)  # "a1b2c3..."
-            html.uuid_short(obj.id, length=8)  # "a1b2c3d4..."
-            html.uuid_short(obj.id, show_tooltip=False)  # Just short version
-
-        Returns:
-            SafeString with shortened UUID
-        """
-        uuid_str = str(uuid_value)
-
-        # Remove dashes for cleaner display
-        uuid_clean = uuid_str.replace('-', '')
-
-        # Take first N characters
-        short_uuid = uuid_clean[:length]
-
-        if show_tooltip:
-            return format_html(
-                '<code class="font-mono text-xs bg-base-100 dark:bg-base-800 px-1.5 py-0.5 rounded cursor-help" title="{}">{}</code>',
-                uuid_str,
-                short_uuid
-            )
-
-        return format_html(
-            '<code class="font-mono text-xs bg-base-100 dark:bg-base-800 px-1.5 py-0.5 rounded">{}</code>',
-            short_uuid
-        )
-
-    @staticmethod
-    def markdown_docs(
-        content: Union[str, Path],
-        collapsible: bool = True,
-        title: str = "Documentation",
-        icon: str = "description",
-        max_height: Optional[str] = "500px",
-        enable_plugins: bool = True,
-        default_open: bool = False
-    ) -> SafeString:
-        """
-        Render markdown documentation from string or file with collapsible UI.
-
-        Auto-detects whether content is a file path or markdown string.
-
-        Args:
-            content: Markdown string or path to .md file
-            collapsible: Wrap in collapsible details/summary
-            title: Title for collapsible section
-            icon: Material icon name for title
-            max_height: Max height for scrolling
-            enable_plugins: Enable markdown plugins
-            default_open: Open by default if collapsible
-
-        Usage:
-            # From string with collapse
-            html.markdown_docs(obj.description, title="Description")
-
-            # From file
-            html.markdown_docs("docs/api.md", title="API Documentation")
-
-            # Simple, no collapse
-            html.markdown_docs(obj.notes, collapsible=False)
-
-            # Open by default
-            html.markdown_docs(obj.readme, default_open=True)
-
-        Returns:
-            Rendered markdown with beautiful Tailwind styling
-        """
-        return MarkdownRenderer.render(
-            content=content,
-            collapsible=collapsible,
-            title=title,
-            icon=icon,
-            max_height=max_height,
-            enable_plugins=enable_plugins,
-            default_open=default_open
-        )
+    # === BaseElements ===
+    icon = staticmethod(BaseElements.icon)
+    span = staticmethod(BaseElements.span)
+    text = staticmethod(BaseElements.text)
+    div = staticmethod(BaseElements.div)
+    link = staticmethod(BaseElements.link)
+    empty = staticmethod(BaseElements.empty)
+
+    # === CodeElements ===
+    code = staticmethod(CodeElements.code)
+    code_block = staticmethod(CodeElements.code_block)
+
+    # === BadgeElements ===
+    badge = staticmethod(BadgeElements.badge)
+
+    # === CompositionElements ===
+    inline = staticmethod(CompositionElements.inline)
+    icon_text = staticmethod(CompositionElements.icon_text)
+    header = staticmethod(CompositionElements.header)
+
+    # === FormattingElements ===
+    number = staticmethod(FormattingElements.number)
+    uuid_short = staticmethod(FormattingElements.uuid_short)
+
+    # === KeyValueElements ===
+    key_value = staticmethod(KeyValueElements.key_value)
+    breakdown = staticmethod(KeyValueElements.breakdown)
+    divider = staticmethod(KeyValueElements.divider)
+    key_value_list = staticmethod(KeyValueElements.key_value_list)
+
+    # === ProgressElements ===
+    segment = staticmethod(ProgressElements.segment)
+    progress_bar = staticmethod(ProgressElements.progress_bar)
+
+    # === MarkdownIntegration ===
+    markdown = staticmethod(MarkdownIntegration.markdown)
+    markdown_docs = staticmethod(MarkdownIntegration.markdown_docs)

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

@@ -0,0 +1,21 @@
+"""
+Markdown rendering utilities for Django Admin.
+
+Provides MarkdownRenderer and mermaid plugin support.
+"""
+
+from .mermaid_plugin import (
+    get_mermaid_resources,
+    get_mermaid_script,
+    get_mermaid_styles,
+    mermaid_plugin,
+)
+from .renderer import MarkdownRenderer
+
+__all__ = [
+    "MarkdownRenderer",
+    "mermaid_plugin",
+    "get_mermaid_styles",
+    "get_mermaid_script",
+    "get_mermaid_resources",
+]

django_cfg/modules/django_admin/widgets/__init__.py

@@ -2,8 +2,11 @@
 Widget system for Django Admin.
 """
 
+from .encrypted_field_widget import EncryptedFieldWidget, EncryptedPasswordWidget
 from .registry import WidgetRegistry
 
 __all__ = [
     "WidgetRegistry",
+    "EncryptedFieldWidget",
+    "EncryptedPasswordWidget",
 ]

django_cfg/modules/django_admin/widgets/encrypted_field_widget.py

@@ -0,0 +1,66 @@
+"""
+Custom widget for encrypted fields with copy button.
+"""
+from typing import Any, Optional
+
+from unfold.widgets import UnfoldAdminPasswordInput, UnfoldAdminTextInputWidget
+
+
+class EncryptedFieldWidget(UnfoldAdminTextInputWidget):
+    """
+    Text input widget for encrypted fields with copy-to-clipboard button.
+
+    Extends UnfoldAdminTextInputWidget to add a copy button on the right side.
+    """
+
+    template_name = "django_admin/widgets/encrypted_field.html"
+
+    def __init__(self, attrs: Optional[dict[str, Any]] = None, show_copy_button: bool = True) -> None:
+        """
+        Initialize the widget.
+
+        Args:
+            attrs: Widget attributes
+            show_copy_button: Whether to show the copy button (default: True)
+        """
+        self.show_copy_button = show_copy_button
+        super().__init__(attrs=attrs)
+
+    def get_context(self, name, value, attrs):
+        """Add copy button context."""
+        context = super().get_context(name, value, attrs)
+        context['widget']['show_copy_button'] = self.show_copy_button
+        return context
+
+
+class EncryptedPasswordWidget(UnfoldAdminPasswordInput):
+    """
+    Password input widget for encrypted fields with copy button.
+
+    Extends UnfoldAdminPasswordInput to add a copy button on the right side.
+    """
+
+    template_name = "django_admin/widgets/encrypted_password.html"
+
+    def __init__(
+        self,
+        attrs: Optional[dict[str, Any]] = None,
+        render_value: bool = False,
+        show_copy_button: bool = True
+    ) -> None:
+        """
+        Initialize the widget.
+
+        Args:
+            attrs: Widget attributes
+            render_value: Whether to render the value (default: False)
+            show_copy_button: Whether to show the copy button (default: True)
+        """
+        self.show_copy_button = show_copy_button
+        super().__init__(attrs=attrs, render_value=render_value)
+
+    def get_context(self, name, value, attrs):
+        """Add copy button context."""
+        context = super().get_context(name, value, attrs)
+        context['widget']['show_copy_button'] = self.show_copy_button
+        return context

django_cfg/modules/django_admin/widgets/registry.py

@@ -208,3 +208,45 @@ def _render_image(obj: Any, field: str, config: Dict[str, Any]) -> str:
 
 # Image widget
 WidgetRegistry.register("image", _render_image)
+
+
+def _render_short_uuid(obj: Any, field: str, config: Dict[str, Any]) -> str:
+    """Render a shortened UUID with tooltip."""
+    from django.utils.safestring import mark_safe
+
+    # Get UUID value
+    uuid_value = getattr(obj, field, None)
+
+    if not uuid_value:
+        return config.get('empty_value', "—")
+
+    # Convert to string and remove dashes
+    uuid_str = str(uuid_value).replace('-', '')
+
+    # Get configuration
+    length = config.get('length', 8)
+    show_full_on_hover = config.get('show_full_on_hover', True)
+    copy_on_click = config.get('copy_on_click', True)
+
+    # Truncate to specified length
+    short_uuid = uuid_str[:length]
+
+    # Build HTML
+    if show_full_on_hover:
+        title_attr = f' title="{uuid_value}"'
+    else:
+        title_attr = ''
+
+    if copy_on_click:
+        # Add click-to-copy functionality
+        copy_attr = f' onclick="navigator.clipboard.writeText(\'{uuid_value}\'); this.style.backgroundColor=\'#e8f5e9\'; setTimeout(() => this.style.backgroundColor=\'\', 500);" style="cursor: pointer;"'
+    else:
+        copy_attr = ''
+
+    html = f'<code{title_attr}{copy_attr}>{short_uuid}</code>'
+
+    return mark_safe(html)
+
+
+# ShortUUID widget
+WidgetRegistry.register("short_uuid", _render_short_uuid)

django_cfg/modules/django_client/core/generator/python/files_generator.py

@@ -161,20 +161,12 @@ class FilesGenerator:
         )
 
     def generate_schema_file(self, openapi_schema: dict) -> GeneratedFile:
-        """Generate schema.py with OpenAPI schema as dict."""
-        # First, convert to pretty JSON
-        schema_json = json.dumps(openapi_schema, indent=4, ensure_ascii=False)
-
-        # Convert JSON literals to Python literals
-        schema_json = re.sub(r'\btrue\b', 'True', schema_json)
-        schema_json = re.sub(r'\bfalse\b', 'False', schema_json)
-        schema_json = re.sub(r'\bnull\b', 'None', schema_json)
-
-        template = self.jinja_env.get_template('utils/schema.py.jinja')
-        content = template.render(schema_dict=schema_json)
+        """Generate schema.json with OpenAPI schema."""
+        # Generate JSON file with proper formatting
+        content = json.dumps(openapi_schema, indent=4, ensure_ascii=False)
 
         return GeneratedFile(
-            path="schema.py",
+            path="schema.json",
             content=content,
-            description="OpenAPI Schema",
+            description="OpenAPI Schema (JSON format)",
         )

django_cfg/modules/django_client/core/generator/python/templates/api_wrapper.py.jinja

@@ -127,14 +127,26 @@ class API:
         """Get current base URL."""
         return self.base_url
 
-    def get_schema(self) -> dict[str, Any]:
+    def get_schema_path(self) -> str:
         """
-        Get OpenAPI schema.
+        Get OpenAPI schema path.
 
         Returns:
-            Complete OpenAPI specification for this API
+            Path to the OpenAPI schema JSON file
+
+        Note:
+            The OpenAPI schema is available in the schema.json file.
+            You can load it dynamically using:
+            ```python
+            import json
+            from pathlib import Path
+
+            schema_path = Path(__file__).parent / 'schema.json'
+            with open(schema_path) as f:
+                schema = json.load(f)
+            ```
         """
-        return OPENAPI_SCHEMA
+        return './schema.json'
 
     async def __aenter__(self) -> 'API':
         """Async context manager entry."""