django-cfg 1.4.108__py3-none-any.whl → 1.4.110__py3-none-any.whl

django_cfg/modules/django_admin/IMPORT_EXPORT_FIX.md

@@ -1,72 +0,0 @@
-# Import/Export Button Fix
-
-## Problem
-
-Import/Export buttons in `PydanticAdmin` were displaying incorrectly because:
-
-1. `PydanticAdmin` was using the original `ImportExportModelAdmin` from django-import-export
-2. Original django-import-export templates don't integrate properly with Unfold UI
-3. Buttons were styled as tabs instead of toolbar buttons
-
-## Solution
-
-Updated `PydanticAdmin` base class to use django_cfg's custom `ImportExportMixin`:
-
-### Before
-```python
-class UnfoldImportExportModelAdmin(ImportExportModelAdmin, UnfoldModelAdmin):
-    pass
-```
-
-### After
-```python
-class UnfoldImportExportModelAdmin(UnfoldModelAdmin, ImportExportMixin):
-    pass
-```
-
-## Changes Made
-
-1. **MRO (Method Resolution Order)**:
-   - `UnfoldModelAdmin` comes first (for template priority)
-   - `ImportExportMixin` comes second (adds import/export functionality)
-
-2. **Custom Templates** (`django_cfg.modules.django_import_export`):
-   - Custom `change_list_*.html` templates that extend Unfold's base
-   - Properly styled import/export buttons as round icons
-   - Import button: green with upload icon
-   - Export button: blue with download icon
-
-3. **Integration**:
-   - Uses Unfold's forms (`ImportForm`, `ExportForm`)
-   - Buttons appear in `object-tools-items` block (next to "Add" button)
-   - Full dark mode support
-
-## Result
-
-Now `PydanticAdmin` admins with `import_export_enabled=True` will have:
-- ✅ Properly styled import/export buttons
-- ✅ Consistent Unfold UI
-- ✅ Round icon buttons matching the design system
-- ✅ Correct positioning in the toolbar
-
-## Usage
-
-No changes required in user code - this fix is automatic:
-
-```python
-from django_cfg.modules.django_admin import AdminConfig
-from django_cfg.modules.django_admin.base import PydanticAdmin
-
-config = AdminConfig(
-    model=MyModel,
-    import_export_enabled=True,
-    resource_class=MyModelResource,
-    list_display=["name", "status"],
-)
-
-@admin.register(MyModel)
-class MyModelAdmin(PydanticAdmin):
-    config = config
-```
-
-The import/export buttons will now display correctly!

django_cfg/modules/django_admin/RESOURCE_CONFIG_ENHANCEMENT.md

@@ -1,350 +0,0 @@
-# ResourceConfig & BackgroundTaskConfig Enhancement
-
-## Summary
-
-Enhanced django-admin module with declarative import/export configuration and background task support.
-
-## New Features
-
-### 1. ResourceConfig
-
-Declarative configuration for django-import-export Resource classes.
-
-**Location:** `django_cfg/modules/django_admin/config/resource_config.py`
-
-**Features:**
-- Field selection and exclusion
-- Import ID fields configuration
-- Import/export behavior control
-- Hook support (before/after import, per-row hooks)
-- Export field ordering
-- Batch processing options
-
-**Example:**
-```python
-from django_cfg.modules.django_admin import ResourceConfig
-
-resource_config = ResourceConfig(
-    fields=['host', 'port', 'username', 'password'],
-    exclude=['metadata', 'config'],
-    import_id_fields=['host', 'port'],
-    skip_unchanged=True,
-    after_import_row='apps.myapp.tasks.test_after_import',
-    batch_size=100,
-)
-```
-
-### 2. BackgroundTaskConfig
-
-Configuration for background task processing.
-
-**Location:** `django_cfg/modules/django_admin/config/background_task_config.py`
-
-**Features:**
-- Task runner selection (rearq, celery, django_q, sync)
-- Batch size configuration
-- Timeout settings
-- Retry policy
-- Priority levels
-
-**Example:**
-```python
-from django_cfg.modules.django_admin import BackgroundTaskConfig
-
-background_config = BackgroundTaskConfig(
-    enabled=True,
-    task_runner='rearq',
-    batch_size=50,
-    timeout=300,
-    retry_on_failure=True,
-    max_retries=3,
-)
-```
-
-### 3. Enhanced AdminConfig
-
-**Updated:** `django_cfg/modules/django_admin/config/admin_config.py`
-
-**New Fields:**
-```python
-class AdminConfig(BaseModel):
-    # ... existing fields ...
-
-    # Import/Export enhancement
-    resource_config: Optional[ResourceConfig] = None
-
-    # Background task processing
-    background_task_config: Optional[BackgroundTaskConfig] = None
-```
-
-### 4. Enhanced PydanticAdmin
-
-**Updated:** `django_cfg/modules/django_admin/base/pydantic_admin.py`
-
-**Key Changes:**
-- `_generate_resource_class()` now uses ResourceConfig if provided
-- Auto-generates Resource with hooks support
-- Dynamically attaches hook methods to Resource class
-
-**Hook Support:**
-- `before_import` - Called before import starts
-- `after_import` - Called after import completes
-- `before_import_row` - Called before each row import
-- `after_import_row` - Called after each row import (★ most useful)
-
-## Usage Example
-
-### Complete Proxy Admin with Import/Export
-
-```python
-from django_cfg.modules.django_admin import (
-    ActionConfig,
-    AdminConfig,
-    BackgroundTaskConfig,
-    ResourceConfig,
-)
-
-proxy_config = AdminConfig(
-    model=Proxy,
-
-    # Enable import/export with ResourceConfig
-    import_export_enabled=True,
-    resource_config=ResourceConfig(
-        fields=[
-            'host', 'port', 'proxy_type', 'proxy_mode',
-            'username', 'password',
-            'provider', 'country',
-        ],
-        exclude=['metadata', 'config', 'last_error'],
-        import_id_fields=['host', 'port', 'provider'],
-        skip_unchanged=True,
-        # Auto-test after import
-        after_import_row='apps.proxies.tasks.after_import_row_test_proxy',
-    ),
-
-    # Background task configuration
-    background_task_config=BackgroundTaskConfig(
-        enabled=True,
-        task_runner='rearq',
-        batch_size=50,
-        timeout=300,
-    ),
-
-    # Admin actions
-    actions=[
-        ActionConfig(
-            name='test_selected_proxies',
-            description='Test selected proxies',
-            variant='warning',
-            icon='speed',
-            handler='apps.proxies.admin.actions.test_selected_proxies',
-        ),
-    ],
-
-    list_display=['host', 'port', 'status', 'success_rate'],
-)
-
-@admin.register(Proxy)
-class ProxyAdmin(PydanticAdmin):
-    config = proxy_config
-```
-
-### Hook Implementation
-
-```python
-# apps/proxies/tasks.py
-
-def after_import_row_test_proxy(row, row_result, **kwargs):
-    """Hook called after each proxy import."""
-
-    # Skip if dry run
-    if kwargs.get('dry_run'):
-        return
-
-    # Only test new proxies
-    if row_result.import_type == 'new':
-        proxy = row_result.instance
-
-        # Queue async test
-        from api.workers import get_worker
-        worker = get_worker()
-        worker.enqueue_task(
-            'apps.proxies.tasks.test_proxy_async',
-            proxy_id=str(proxy.id)
-        )
-```
-
-## Benefits
-
-### Before (Manual Resource Class)
-```python
-from import_export import resources
-
-class ProxyResource(resources.ModelResource):
-    class Meta:
-        model = Proxy
-        fields = ('host', 'port', 'username', 'password')
-        import_id_fields = ['host', 'port']
-        skip_unchanged = True
-
-    def after_import_row(self, row, row_result, **kwargs):
-        # Custom logic here
-        pass
-
-proxy_config = AdminConfig(
-    model=Proxy,
-    import_export_enabled=True,
-    resource_class=ProxyResource,  # Manual class
-)
-```
-
-### After (Declarative ResourceConfig)
-```python
-proxy_config = AdminConfig(
-    model=Proxy,
-    import_export_enabled=True,
-    resource_config=ResourceConfig(
-        fields=['host', 'port', 'username', 'password'],
-        import_id_fields=['host', 'port'],
-        skip_unchanged=True,
-        after_import_row='apps.proxies.tasks.after_import_row_test_proxy',
-    ),
-)
-```
-
-**Advantages:**
-- ✅ No separate Resource class needed
-- ✅ All configuration in one place
-- ✅ Type-safe with Pydantic validation
-- ✅ Reusable across multiple admins
-- ✅ Hook as string path (lazy import)
-- ✅ Auto-generated Resource with full control
-
-## Dependencies Added
-
-**pyproject.toml updates:**
-```toml
-dependencies = [
-    # ... existing ...
-    "pytz>=2025.1",
-    "httpx>=0.28.1,<1.0",
-]
-```
-
-- `pytz` - Timezone support for datetime operations
-- `httpx` - Modern HTTP client for proxy testing
-
-## Files Changed
-
-### django-cfg Core
-1. `config/resource_config.py` - NEW
-2. `config/background_task_config.py` - NEW
-3. `config/admin_config.py` - MODIFIED (added new configs)
-4. `config/__init__.py` - MODIFIED (exports)
-5. `base/pydantic_admin.py` - MODIFIED (Resource generation)
-6. `__init__.py` - MODIFIED (exports)
-7. `pyproject.toml` - MODIFIED (dependencies)
-
-### stockapis Implementation
-1. `apps/proxies/admin/proxy_admin.py` - Uses ResourceConfig
-2. `apps/proxies/admin/actions.py` - NEW (admin actions)
-3. `apps/proxies/services/proxy_tester.py` - NEW (testing logic)
-4. `apps/proxies/tasks.py` - NEW (background tasks)
-5. `apps/proxies/@docs/IMPORT_EXPORT_SETUP.md` - NEW (docs)
-
-## Backward Compatibility
-
-✅ **100% Backward Compatible**
-
-Old code still works:
-```python
-# Old way - still works
-proxy_config = AdminConfig(
-    model=Proxy,
-    import_export_enabled=True,
-    resource_class=MyCustomResource,  # Manual class
-)
-
-# New way - alternative
-proxy_config = AdminConfig(
-    model=Proxy,
-    import_export_enabled=True,
-    resource_config=ResourceConfig(...),  # Declarative
-)
-```
-
-Priority:
-1. If `resource_class` provided → use it (legacy)
-2. If `resource_config` provided → auto-generate Resource
-3. If neither → auto-generate basic Resource
-
-## Testing
-
-```bash
-# Test django-cfg imports
-cd django-cfg-dev
-poetry run python -c "from django_cfg.modules.django_admin import ResourceConfig, BackgroundTaskConfig; print('✅ OK')"
-
-# Test stockapis admin
-cd stockapis
-poetry run python manage.py check --tag admin
-
-# Test in browser
-poetry run python manage.py runserver
-# Visit: http://localhost:8000/admin/proxies/proxy/
-```
-
-## Future Enhancements
-
-- [ ] `ResourceConfig.field_widgets` - Custom widgets for fields
-- [ ] `ResourceConfig.validators` - Custom validation rules
-- [ ] `ResourceConfig.transformers` - Data transformation before import
-- [ ] Progress tracking for large imports
-- [ ] Import history and rollback
-- [ ] Scheduled imports via cron
-- [ ] API endpoint for programmatic imports
-
-## Migration Guide
-
-### For Existing Projects
-
-1. Update django-cfg to latest version
-2. Optional: Replace manual Resource classes with ResourceConfig
-3. Optional: Add BackgroundTaskConfig for async operations
-4. Optional: Add after_import_row hooks for post-import processing
-
-### Example Migration
-
-**Before:**
-```python
-# resources.py
-class ProxyResource(resources.ModelResource):
-    class Meta:
-        model = Proxy
-        fields = ('host', 'port')
-
-# admin.py
-config = AdminConfig(
-    model=Proxy,
-    import_export_enabled=True,
-    resource_class=ProxyResource,
-)
-```
-
-**After:**
-```python
-# admin.py only - no resources.py needed
-config = AdminConfig(
-    model=Proxy,
-    import_export_enabled=True,
-    resource_config=ResourceConfig(
-        fields=['host', 'port'],
-    ),
-)
-```
-
-## Version
-
-- **django-cfg**: 1.4.106+
-- **Python**: 3.12+
-- **Django**: 5.2+

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)