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

django_cfg/modules/django_admin/utils/displays.py

@@ -1,203 +0,0 @@
-"""
-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_client/system/__init__.py

@@ -1,24 +0,0 @@
-"""
-MJS Client Generation System for django-cfg
-
-This module provides a modular system for generating JavaScript ES modules
-with JSDoc type annotations from OpenAPI schemas.
-
-Components:
-- base_generator: Base class with common utilities
-- schema_parser: OpenAPI schema parsing and type extraction
-- mjs_generator: Main generator for MJS clients
-- templates/: Jinja2 templates for code generation
-"""
-
-from .base_generator import BaseGenerator
-from .mjs_generator import MJSGenerator
-from .schema_parser import SchemaParser
-
-__all__ = [
-    'BaseGenerator',
-    'SchemaParser',
-    'MJSGenerator'
-]
-
-__version__ = '1.0.0'

django_cfg/modules/django_client/system/base_generator.py

@@ -1,123 +0,0 @@
-"""
-Base generator class for MJS clients.
-Handles schema loading and common utilities.
-"""
-
-import json
-from pathlib import Path
-from typing import Any, Dict
-
-import yaml
-from jinja2 import Environment, FileSystemLoader
-
-
-class BaseGenerator:
-    """Base class for API client generation."""
-
-    def __init__(self, schema_path: Path, output_dir: Path):
-        """Initialize the generator with schema and output directory."""
-        self.schema_path = schema_path
-        self.output_dir = output_dir
-        self.schema = self._load_schema()
-
-        # Set up Jinja2 environment
-        template_dir = Path(__file__).parent / 'templates'
-        self.jinja_env = Environment(
-            loader=FileSystemLoader(template_dir),
-            trim_blocks=True,
-            lstrip_blocks=True,
-            keep_trailing_newline=True
-        )
-
-    def _load_schema(self) -> Dict[str, Any]:
-        """Load OpenAPI schema from JSON/YAML file."""
-        with open(self.schema_path) as f:
-            if self.schema_path.suffix == '.yaml':
-                return yaml.safe_load(f)
-            else:
-                return json.load(f)
-
-    def to_camel_case(self, snake_str: str) -> str:
-        """Convert snake_case to camelCase."""
-        snake_str = snake_str.replace(' ', '_').replace('-', '_')
-        components = snake_str.split('_')
-        return components[0] + ''.join(x.title() for x in components[1:])
-
-    def to_pascal_case(self, snake_str: str) -> str:
-        """Convert snake_case to PascalCase."""
-        snake_str = snake_str.replace(' ', '_').replace('-', '_')
-        return ''.join(word.capitalize() for word in snake_str.split('_'))
-
-    def sanitize_identifier(self, name: str) -> str:
-        """Sanitize a name to be a valid JavaScript identifier."""
-        # Replace spaces and special chars with underscores
-        sanitized = name.replace(' ', '_').replace('-', '_').replace('.', '_')
-        # Remove any remaining invalid characters
-        import re
-        sanitized = re.sub(r'[^a-zA-Z0-9_]', '', sanitized)
-        # Ensure it doesn't start with a number
-        if sanitized and sanitized[0].isdigit():
-            sanitized = '_' + sanitized
-        return sanitized
-
-    def get_type_from_schema(self, schema: Dict[str, Any]) -> str:
-        """Extract JavaScript type from OpenAPI schema."""
-        if not schema:
-            return 'any'
-
-        # Handle references
-        if '$ref' in schema:
-            ref_name = schema['$ref'].split('/')[-1]
-            return ref_name
-
-        # Handle arrays
-        if schema.get('type') == 'array':
-            items_type = self.get_type_from_schema(schema.get('items', {}))
-            return f'{items_type}[]'
-
-        # Handle objects
-        if schema.get('type') == 'object':
-            # If it has properties, we could generate an interface
-            # For now, just return a generic object type
-            if 'properties' in schema:
-                return 'Object'
-            return 'any'
-
-        # Handle primitive types
-        type_mapping = {
-            'string': 'string',
-            'integer': 'number',
-            'number': 'number',
-            'boolean': 'boolean',
-            'null': 'null'
-        }
-
-        openapi_type = schema.get('type', 'any')
-        return type_mapping.get(openapi_type, 'any')
-
-    def extract_response_type(self, operation: Dict[str, Any]) -> str:
-        """Extract the response type from an operation."""
-        responses = operation.get('responses', {})
-
-        # Look for successful response (200, 201, etc.)
-        for status in ['200', '201', '202', '204']:
-            if status in responses:
-                response = responses[status]
-
-                # Handle 204 No Content
-                if status == '204':
-                    return 'void'
-
-                # Extract content type
-                content = response.get('content', {})
-                if 'application/json' in content:
-                    schema = content['application/json'].get('schema', {})
-                    return self.get_type_from_schema(schema)
-
-        # Default to any if we can't determine the type
-        return 'any'
-
-    def render_template(self, template_name: str, **context) -> str:
-        """Render a Jinja2 template with the given context."""
-        template = self.jinja_env.get_template(template_name)
-        return template.render(**context)

django_cfg/modules/django_client/system/generate_mjs_clients.py

@@ -1,174 +0,0 @@
-#!/usr/bin/env python3
-"""
-Script to generate lightweight MJS (ES Module) clients for django-cfg project.
-
-This script generates JavaScript ES modules with JSDoc type annotations
-organized by Django apps for use in Django HTML templates.
-
-Usage:
-    poetry run python src/django_cfg/modules/django_client/system/generate_mjs_clients.py
-    poetry run python src/django_cfg/modules/django_client/system/generate_mjs_clients.py --clean
-"""
-
-import argparse
-import os
-import shutil
-import subprocess
-import sys
-from pathlib import Path
-
-# Add current directory to path for imports
-sys.path.insert(0, str(Path(__file__).parent))
-
-from mjs_generator import MJSGenerator
-
-
-def main():
-    """Main function to generate MJS clients."""
-
-    parser = argparse.ArgumentParser(
-        description='Generate MJS API clients with JSDoc types for django-cfg project'
-    )
-    parser.add_argument(
-        '--clean',
-        action='store_true',
-        help='Clean existing files before generation'
-    )
-    parser.add_argument(
-        '--schema',
-        type=str,
-        help='Path to OpenAPI schema file (YAML or JSON)'
-    )
-    parser.add_argument(
-        '--output',
-        type=str,
-        help='Output directory for generated clients'
-    )
-
-    args = parser.parse_args()
-
-    # Determine paths
-    script_dir = Path(__file__).parent
-    django_client_dir = script_dir.parent  # django_client module
-    modules_dir = django_client_dir.parent  # modules
-    django_cfg_dir = modules_dir.parent  # django_cfg
-    src_dir = django_cfg_dir.parent  # src
-    dev_dir = src_dir.parent  # django-cfg-dev
-    example_django_dir = dev_dir.parent / "django-cfg-example" / "django"
-
-    # Output directory for MJS clients
-    if args.output:
-        mjs_output_dir = Path(args.output)
-    else:
-        mjs_output_dir = django_cfg_dir / "static" / "js" / "api"
-
-    # Schema location
-    if args.schema:
-        schema_path = Path(args.schema)
-    else:
-        schema_path = example_django_dir / "openapi" / "schemas" / "cfg.yaml"
-
-    print("🚀 Generating MJS API clients with JSDoc type annotations...")
-    print(f"📁 Schema: {schema_path}")
-    print(f"📁 Output: {mjs_output_dir}")
-
-    # Generate schema if it doesn't exist
-    if not schema_path.exists():
-        print("⚙️  Generating OpenAPI schema first...")
-        os.chdir(example_django_dir)
-
-        result = subprocess.run(
-            ["poetry", "run", "python", "manage.py", "generate_client", "--typescript", "--no-python"],
-            capture_output=True,
-            text=True
-        )
-
-        if result.returncode != 0 or not schema_path.exists():
-            print("❌ Error: Could not generate schema")
-            print(result.stderr)
-            sys.exit(1)
-
-    # Check for dependencies
-    try:
-        import yaml
-    except ImportError:
-        print("❌ PyYAML is required. Install with: pip install pyyaml")
-        sys.exit(1)
-
-    try:
-        import jinja2
-    except ImportError:
-        print("❌ Jinja2 is required. Install with: pip install jinja2")
-        sys.exit(1)
-
-    # Generate MJS clients
-    try:
-        generator = MJSGenerator(schema_path, mjs_output_dir)
-        file_count = generator.generate()
-
-        print("\n✅ MJS clients generated successfully!")
-        print(f"📊 Generated {file_count} files in {mjs_output_dir}")
-        print("📂 Structure: Organized by Django apps with JSDoc types")
-
-        # Clean up openapi directory if it was created
-        openapi_dir = example_django_dir / "openapi"
-        if openapi_dir.exists():
-            print(f"🧹 Cleaning up example project openapi directory: {openapi_dir}")
-            shutil.rmtree(openapi_dir)
-
-        print("\n📝 Usage examples in Django template:")
-        print("""
-    <!-- Import from app folder with type support -->
-    <script type="module">
-        // Your IDE will provide autocomplete and type hints!
-        import { tasksAPI } from '{% static "api/tasks/index.mjs" %}';
-
-        async function loadTaskStats() {
-            try {
-                // IDE knows the return type from JSDoc annotations
-                const stats = await tasksAPI.cfgTasksApiTasksStatsRetrieve();
-                console.log('Task Stats:', stats);
-            } catch (error) {
-                // APIError type is documented
-                console.error('Error:', error);
-            }
-        }
-
-        loadTaskStats();
-    </script>
-
-    <!-- Import multiple APIs from main index -->
-    <script type="module">
-        import { tasksAPI, paymentsAPI } from '{% static "api/index.mjs" %}';
-
-        // Both APIs have full JSDoc documentation
-        const tasks = await tasksAPI.cfgTasksApiTasksStatsRetrieve();
-        const webhooks = await paymentsAPI.cfgPaymentsWebhooksHealthRetrieve();
-    </script>
-
-    <!-- Use with custom base URL -->
-    <script type="module">
-        import { TasksAPI } from '{% static "api/tasks/index.mjs" %}';
-
-        // Constructor is documented with JSDoc
-        const api = new TasksAPI('https://api.example.com');
-        const stats = await api.cfgTasksApiTasksStatsRetrieve();
-    </script>
-        """)
-
-        print("\n🎯 Benefits of JSDoc types:")
-        print("   • IDE autocomplete and IntelliSense")
-        print("   • Type checking in VS Code and other editors")
-        print("   • Inline documentation in your editor")
-        print("   • Works with TypeScript if needed")
-        print("   • No build step required!")
-
-    except Exception as e:
-        print(f"❌ Error: {e}")
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)
-
-
-if __name__ == '__main__':
-    main()