django-cfg 1.4.10__py3-none-any.whl → 1.4.13__py3-none-any.whl

django_cfg/modules/django_client/spectacular/enum_naming.py

@@ -0,0 +1,192 @@
+"""
+Auto-fix enum naming collisions in OpenAPI schema.
+
+This postprocessing hook automatically generates unique, descriptive enum names
+based on model names to avoid collisions like "Status50eEnum", "StatusA98Enum".
+
+Instead generates: "ProductStatusEnum", "OrderStatusEnum", "PostStatusEnum", etc.
+"""
+
+import logging
+from typing import Dict, Any, Optional
+import re
+
+logger = logging.getLogger(__name__)
+
+
+def auto_fix_enum_names(result: Dict[str, Any], generator, request, public) -> Dict[str, Any]:
+    """
+    DRF Spectacular postprocessing hook to auto-fix enum naming collisions.
+
+    Automatically detects and fixes enum naming collisions by using model names.
+
+    Args:
+        result: OpenAPI schema dict
+        generator: Schema generator instance
+        request: HTTP request
+        public: Whether schema is public
+
+    Returns:
+        Modified OpenAPI schema with fixed enum names
+
+    Example:
+        Before: Status50eEnum, StatusA98Enum (collision hashes)
+        After:  ProductStatusEnum, OrderStatusEnum (descriptive names)
+    """
+
+    if 'components' not in result or 'schemas' not in result['components']:
+        return result
+
+    schemas = result['components']['schemas']
+
+    # Track enum references and their sources (model + field)
+    enum_sources: Dict[str, list] = {}  # enum_name -> [(model_name, field_name, choices)]
+    enum_renames: Dict[str, str] = {}   # old_name -> new_name
+
+    # Step 1: Find all enums and their sources
+    for schema_name, schema in schemas.items():
+        if schema.get('type') == 'object' and 'properties' in schema:
+            # This is a model schema
+            model_name = _extract_model_name(schema_name)
+
+            for field_name, field_schema in schema['properties'].items():
+                # Check if field references an enum
+                if '$ref' in field_schema:
+                    enum_ref = field_schema['$ref']
+                    if '#/components/schemas/' in enum_ref:
+                        enum_name = enum_ref.split('/')[-1]
+
+                        # Track enum source
+                        if enum_name not in enum_sources:
+                            enum_sources[enum_name] = []
+
+                        enum_sources[enum_name].append((model_name, field_name))
+
+    # Step 2: Detect collisions and generate better names
+    for enum_name, sources in enum_sources.items():
+        # Check if enum looks like a collision (contains hash or generic name)
+        if _is_collision_enum(enum_name):
+            # Multiple models use this enum - need unique names
+            if len(sources) == 1:
+                # Single source - generate descriptive name
+                model_name, field_name = sources[0]
+                new_name = _generate_enum_name(model_name, field_name)
+                enum_renames[enum_name] = new_name
+
+                logger.debug(f"  Renaming {enum_name} -> {new_name} (from {model_name}.{field_name})")
+
+    # Step 3: Apply renames to schema
+    if enum_renames:
+        logger.info(f"🔧 Auto-fixed {len(enum_renames)} enum naming collision(s)")
+        _apply_enum_renames(result, enum_renames)
+
+    return result
+
+
+def _extract_model_name(schema_name: str) -> str:
+    """
+    Extract model name from schema name.
+
+    Examples:
+        "Product" -> "Product"
+        "ProductDetail" -> "Product"
+        "PaginatedProductList" -> "Product"
+    """
+    # Remove common prefixes/suffixes
+    name = schema_name
+
+    # Remove pagination wrapper
+    if name.startswith('Paginated') and name.endswith('List'):
+        name = name[9:-4]  # Remove "Paginated" and "List"
+
+    # Remove common suffixes
+    for suffix in ['Serializer', 'Detail', 'List', 'Create', 'Update']:
+        if name.endswith(suffix):
+            name = name[:-len(suffix)]
+            break
+
+    return name
+
+
+def _is_collision_enum(enum_name: str) -> bool:
+    """
+    Check if enum name looks like a collision (contains hash).
+
+    Examples:
+        "Status50eEnum" -> True (has hash)
+        "StatusA98Enum" -> True (has hash)
+        "ProductStatusEnum" -> False (descriptive)
+    """
+    # Check if enum contains hash-like patterns (3+ hex chars)
+    if re.search(r'[0-9A-Fa-f]{3,}Enum$', enum_name):
+        return True
+
+    # Check for generic single-word enums that are likely collisions
+    # (e.g., "StatusEnum" without model prefix)
+    if re.match(r'^[A-Z][a-z]+Enum$', enum_name):
+        # Single word + Enum - likely collision
+        return True
+
+    return False
+
+
+def _generate_enum_name(model_name: str, field_name: str) -> str:
+    """
+    Generate descriptive enum name from model and field.
+
+    Examples:
+        ("Product", "status") -> "ProductStatusEnum"
+        ("Order", "status") -> "OrderStatusEnum"
+        ("Post", "status") -> "PostStatusEnum"
+    """
+    # Capitalize field name
+    field_capitalized = field_name.capitalize()
+
+    # Combine: ModelName + FieldName + Enum
+    return f"{model_name}{field_capitalized}Enum"
+
+
+def _apply_enum_renames(schema: Dict[str, Any], renames: Dict[str, str]) -> None:
+    """
+    Apply enum renames throughout the schema.
+
+    Renames both:
+    1. Schema component definitions (components/schemas/OldName -> NewName)
+    2. All references to renamed enums ($ref: #/components/schemas/OldName)
+    """
+    if 'components' not in schema or 'schemas' not in schema['components']:
+        return
+
+    schemas = schema['components']['schemas']
+
+    # Step 1: Rename schema definitions
+    for old_name, new_name in renames.items():
+        if old_name in schemas:
+            schemas[new_name] = schemas.pop(old_name)
+            logger.debug(f"  Renamed schema: {old_name} -> {new_name}")
+
+    # Step 2: Update all $ref references
+    _update_refs_recursive(schema, renames)
+
+
+def _update_refs_recursive(obj: Any, renames: Dict[str, str]) -> None:
+    """
+    Recursively update all $ref references in schema.
+    """
+    if isinstance(obj, dict):
+        # Check if this dict contains a $ref
+        if '$ref' in obj:
+            ref = obj['$ref']
+            if '#/components/schemas/' in ref:
+                enum_name = ref.split('/')[-1]
+                if enum_name in renames:
+                    obj['$ref'] = f"#/components/schemas/{renames[enum_name]}"
+
+        # Recurse into dict values
+        for value in obj.values():
+            _update_refs_recursive(value, renames)
+
+    elif isinstance(obj, list):
+        # Recurse into list items
+        for item in obj:
+            _update_refs_recursive(item, renames)

django_cfg/modules/django_client/urls.py

@@ -0,0 +1,72 @@
+"""
+Django URL integration.
+
+Provides URL patterns for OpenAPI schema generation.
+Each configured group gets its own schema endpoint.
+"""
+
+from typing import List, Any
+
+
+def _is_django_configured() -> bool:
+    """Check if Django settings are configured."""
+    try:
+        from django.conf import settings
+        return settings.configured
+    except ImportError:
+        return False
+
+
+def get_openapi_urls() -> List[Any]:
+    """
+    Get URL patterns for OpenAPI schema generation.
+
+    Creates URLs for each configured group:
+    - /openapi/{group_name}/schema/ - JSON schema
+
+    Returns:
+        List of Django URL patterns
+    """
+    try:
+        from django.urls import path
+        from drf_spectacular.views import SpectacularAPIView
+        from django_cfg.modules.django_client.core import get_openapi_service
+    except ImportError:
+        return []
+
+    service = get_openapi_service()
+
+    if not service.config or not service.is_enabled():
+        return []
+
+    patterns = []
+
+    for group_name in service.get_group_names():
+        group_config = service.get_group(group_name)
+        if not group_config:
+            continue
+
+        # Schema endpoint for each group
+        patterns.append(
+            path(
+                f'{group_name}/schema/',
+                SpectacularAPIView.as_view(
+                    urlconf=f'openapi_group_{group_name}',
+                    api_version=group_config.version,
+                ),
+                name=f'openapi-schema-{group_name}',
+            )
+        )
+
+    return patterns
+
+
+# Export urlpatterns for django.urls.include()
+# Only create urlpatterns if Django is configured
+if _is_django_configured():
+    urlpatterns = get_openapi_urls()
+else:
+    urlpatterns = []
+
+
+__all__ = ["get_openapi_urls", "urlpatterns"]

django_cfg/{dashboard → modules/django_dashboard}/DEBUG_README.md

@@ -37,7 +37,7 @@ libs/django_cfg/src/django_cfg/debug/dashboard/
 ### 3. Программное использование
 
 ```python
-from django_cfg.dashboard.debug import save_section_render
+from django_cfg.modules.django_dashboard.debug import save_section_render
 
 # В коде секции
 html = section.render()
@@ -62,7 +62,7 @@ dashboard/
 ## Сравнение с архивом
 
 ```python
-from django_cfg.dashboard.debug import get_debugger
+from django_cfg.modules.django_dashboard.debug import get_debugger
 from pathlib import Path
 
 debugger = get_debugger()

django_cfg/{dashboard → modules/django_dashboard}/REFACTORING_SUMMARY.md

@@ -65,7 +65,7 @@ python manage.py debug_dashboard
 ### 2. Автоматическое сохранение рендеров ✅
 При каждом рендере секции автоматически сохраняются через:
 ```python
-from django_cfg.dashboard.debug import save_section_render
+from django_cfg.modules.django_dashboard.debug import save_section_render
 
 save_section_render('overview', html)
 ```

django_cfg/{dashboard → modules/django_dashboard}/management/commands/debug_dashboard.py

@@ -8,11 +8,11 @@ from django.core.management.base import BaseCommand
 from django.test import RequestFactory
 from django.contrib.auth import get_user_model
 
-from django_cfg.dashboard.sections.overview import OverviewSection
-from django_cfg.dashboard.sections.stats import StatsSection
-from django_cfg.dashboard.sections.system import SystemSection
-from django_cfg.dashboard.sections.commands import CommandsSection
-from django_cfg.dashboard.debug import get_debugger
+from django_cfg.modules.django_dashboard.sections.overview import OverviewSection
+from django_cfg.modules.django_dashboard.sections.stats import StatsSection
+from django_cfg.modules.django_dashboard.sections.system import SystemSection
+from django_cfg.modules.django_dashboard.sections.commands import CommandsSection
+from django_cfg.modules.django_dashboard.debug import get_debugger
 
 
 class Command(BaseCommand):