django-cfg 1.4.9__py3-none-any.whl → 1.4.11__py3-none-any.whl

django_cfg/apps/payments/views/api/webhooks.py

@@ -17,9 +17,16 @@ from rest_framework.decorators import api_view, permission_classes
 from rest_framework.permissions import AllowAny
 from rest_framework.response import Response
 from rest_framework.views import APIView
+from drf_spectacular.utils import extend_schema, OpenApiParameter, OpenApiTypes
 
 from ...services.core.webhook_service import WebhookService
 from ...services.types import WebhookValidationRequest, WebhookProcessingResult
+from ..serializers.webhooks import (
+    WebhookResponseSerializer,
+    WebhookHealthSerializer,
+    WebhookStatsSerializer,
+    SupportedProvidersSerializer,
+)
 from django_cfg.modules.django_logging import get_logger
 
 logger = get_logger("webhook_views")
@@ -29,7 +36,7 @@ logger = get_logger("webhook_views")
 class UniversalWebhookView(APIView):
     """
     Universal webhook handler for all payment providers.
-    
+
     Features:
     - Provider-agnostic webhook processing
     - Signature validation and security
@@ -37,13 +44,29 @@ class UniversalWebhookView(APIView):
     - Comprehensive logging and monitoring
     - Integration with ngrok for development
     """
-    
+
     permission_classes = [AllowAny]  # Webhooks don't use standard auth
+    serializer_class = WebhookResponseSerializer  # For OpenAPI schema generation
     
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.webhook_service = WebhookService()
-    
+
+    @extend_schema(
+        summary="Process Webhook",
+        description="Process incoming webhook from payment provider",
+        parameters=[
+            OpenApiParameter(
+                name='provider',
+                description='Payment provider name (nowpayments, stripe, etc.)',
+                required=True,
+                type=OpenApiTypes.STR,
+                location=OpenApiParameter.PATH
+            )
+        ],
+        responses={200: WebhookResponseSerializer},
+        tags=["Webhooks"]
+    )
     def post(self, request: HttpRequest, provider: str) -> JsonResponse:
         """
         Handle incoming webhook from any payment provider.
@@ -144,10 +167,25 @@ class UniversalWebhookView(APIView):
                 request_id
             )
     
+    @extend_schema(
+        summary="Webhook Endpoint Info",
+        description="Get webhook endpoint information for debugging and configuration",
+        parameters=[
+            OpenApiParameter(
+                name='provider',
+                description='Payment provider name',
+                required=True,
+                type=OpenApiTypes.STR,
+                location=OpenApiParameter.PATH
+            )
+        ],
+        responses={200: WebhookResponseSerializer},
+        tags=["Webhooks"]
+    )
     def get(self, request: HttpRequest, provider: str) -> JsonResponse:
         """
         Handle GET requests for webhook endpoint info.
-        
+
         Useful for debugging and provider configuration verification.
         """
         
@@ -314,12 +352,18 @@ class UniversalWebhookView(APIView):
         return JsonResponse(response_data, status=status_code)
 
 
+@extend_schema(
+    summary="Webhook Health Check",
+    description="Check webhook service health status and recent activity metrics",
+    responses={200: WebhookHealthSerializer},
+    tags=["Webhooks"]
+)
 @api_view(['GET'])
 @permission_classes([AllowAny])
 def webhook_health_check(request):
     """
     Health check endpoint for webhook service.
-    
+
     Returns service status and recent activity metrics.
     """
     
@@ -362,12 +406,27 @@ def webhook_health_check(request):
         }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 
 
+@extend_schema(
+    summary="Webhook Statistics",
+    description="Get webhook processing statistics for a given time period",
+    parameters=[
+        OpenApiParameter(
+            name='days',
+            description='Number of days to analyze (1-365)',
+            required=False,
+            type=OpenApiTypes.INT,
+            default=30
+        )
+    ],
+    responses={200: WebhookStatsSerializer},
+    tags=["Webhooks"]
+)
 @api_view(['GET'])
 @permission_classes([AllowAny])
 def webhook_stats(request):
     """
     Get webhook processing statistics.
-    
+
     Query parameters:
     - days: Number of days to analyze (default: 30)
     """
@@ -408,12 +467,18 @@ def webhook_stats(request):
         }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 
 
+@extend_schema(
+    summary="Supported Webhook Providers",
+    description="Get list of supported webhook providers with configuration details",
+    responses={200: SupportedProvidersSerializer},
+    tags=["Webhooks"]
+)
 @api_view(['GET'])
 @permission_classes([AllowAny])
 def supported_providers(request):
     """
     Get list of supported webhook providers.
-    
+
     Returns provider information and webhook URLs.
     """
     

django_cfg/apps/payments/views/overview/serializers.py

@@ -201,5 +201,38 @@ class TimePeriodSerializer(serializers.Serializer):
         ('90d', 'Last 90 days'),
         ('1y', 'Last year'),
     ]
-    
+
     period = serializers.ChoiceField(choices=PERIOD_CHOICES, default='30d')
+
+
+class CurrencyAnalyticsItemSerializer(serializers.Serializer):
+    """
+    Analytics data for a single currency
+    """
+    currency_code = serializers.CharField(help_text="Currency code (e.g., BTC)")
+    currency_name = serializers.CharField(help_text="Currency name (e.g., Bitcoin)")
+    total_payments = serializers.IntegerField(help_text="Total number of payments")
+    total_amount = serializers.FloatField(help_text="Total amount in USD")
+    completed_payments = serializers.IntegerField(help_text="Number of completed payments")
+    average_amount = serializers.FloatField(help_text="Average payment amount in USD")
+    success_rate = serializers.FloatField(help_text="Success rate percentage")
+
+
+class ProviderAnalyticsItemSerializer(serializers.Serializer):
+    """
+    Analytics data for a single payment provider
+    """
+    provider = serializers.CharField(help_text="Provider code")
+    provider_display = serializers.CharField(help_text="Provider display name")
+    total_payments = serializers.IntegerField(help_text="Total number of payments")
+    total_amount = serializers.FloatField(help_text="Total amount in USD")
+    completed_payments = serializers.IntegerField(help_text="Number of completed payments")
+    success_rate = serializers.FloatField(help_text="Success rate percentage")
+
+
+class PaymentAnalyticsResponseSerializer(serializers.Serializer):
+    """
+    Payment analytics response with currency and provider breakdown
+    """
+    currency_analytics = CurrencyAnalyticsItemSerializer(many=True, help_text="Analytics by currency")
+    provider_analytics = ProviderAnalyticsItemSerializer(many=True, help_text="Analytics by provider")

django_cfg/apps/payments/views/overview/views.py

@@ -26,6 +26,7 @@ from .serializers import (
     BalanceOverviewSerializer,
     SubscriptionOverviewSerializer,
     APIKeysOverviewSerializer,
+    PaymentAnalyticsResponseSerializer,
 )
 
 
@@ -95,7 +96,7 @@ from .serializers import (
                 default=10
             )
         ],
-        responses={200: 'object'}  # Generic object since it's a dict with currency_analytics and provider_analytics
+        responses={200: PaymentAnalyticsResponseSerializer}
     ),
     balance_overview=extend_schema(
         summary="Balance Overview",

django_cfg/apps/payments/views/serializers/payments.py

@@ -27,7 +27,7 @@ class PaymentListSerializer(serializers.ModelSerializer):
     status_display = serializers.CharField(source='get_status_display', read_only=True)
     amount_display = serializers.SerializerMethodField(read_only=True)
     
-    def get_amount_display(self, obj):
+    def get_amount_display(self, obj) -> str:
         """Get formatted amount display."""
         return f"${obj.amount_usd:.2f}"
     
@@ -64,23 +64,23 @@ class PaymentSerializer(serializers.ModelSerializer):
     is_failed = serializers.SerializerMethodField(read_only=True)
     is_expired = serializers.SerializerMethodField(read_only=True)
     
-    def get_amount_display(self, obj):
+    def get_amount_display(self, obj) -> str:
         """Get formatted amount display."""
         return f"${obj.amount_usd:.2f}"
     
-    def get_is_pending(self, obj):
+    def get_is_pending(self, obj) -> bool:
         """Check if payment is pending."""
         return obj.status == obj.PaymentStatus.PENDING
     
-    def get_is_completed(self, obj):
+    def get_is_completed(self, obj) -> bool:
         """Check if payment is completed."""
         return obj.status == obj.PaymentStatus.COMPLETED
     
-    def get_is_failed(self, obj):
+    def get_is_failed(self, obj) -> bool:
         """Check if payment is failed."""
         return obj.status == obj.PaymentStatus.FAILED
     
-    def get_is_expired(self, obj):
+    def get_is_expired(self, obj) -> bool:
         """Check if payment is expired."""
         return obj.status == obj.PaymentStatus.EXPIRED
     

django_cfg/apps/urls.py

@@ -5,67 +5,128 @@ Built-in API endpoints for django_cfg functionality.
 """
 
 from django.urls import path, include
-from typing import List
+from typing import List, Dict
 from django.urls import URLPattern
 
 
+def _register_group_urls(patterns: List[URLPattern], groups: Dict) -> None:
+    """
+    Auto-register URLs from OpenAPI groups using convention.
+
+    Convention: cfg_{app} → /cfg/{app}/
+
+    Args:
+        patterns: URL patterns list to append to
+        groups: OpenAPI groups dict
+    """
+    for group_name in groups.keys():
+        # Only django-cfg apps (convention: cfg_*)
+        if not group_name.startswith('cfg_'):
+            continue
+
+        # Extract app name: cfg_payments → payments
+        app_name = group_name[4:]
+
+        # Register main URLs: /cfg/{app}/
+        try:
+            patterns.append(
+                path(f'cfg/{app_name}/', include(f'django_cfg.apps.{app_name}.urls'))
+            )
+        except ImportError:
+            pass  # URL module doesn't exist
+
+        # Register admin URLs: /cfg/{app}/admin/ (if exists)
+        try:
+            patterns.append(
+                path(f'cfg/{app_name}/admin/', include(f'django_cfg.apps.{app_name}.urls_admin'))
+            )
+        except ImportError:
+            pass  # Admin URL module doesn't exist
+
+
+def _register_apps_fallback(patterns: List[URLPattern]) -> None:
+    """
+    Fallback: Register apps when OpenAPI is disabled.
+
+    Uses BaseCfgModule checks to determine which apps are enabled.
+
+    Args:
+        patterns: URL patterns list to append to
+    """
+    from django_cfg.modules.base import BaseCfgModule
+    base_module = BaseCfgModule()
+
+    # Business logic apps
+    if base_module.is_support_enabled():
+        patterns.append(path('cfg/support/', include('django_cfg.apps.support.urls')))
+
+    if base_module.is_accounts_enabled():
+        patterns.append(path('cfg/accounts/', include('django_cfg.apps.accounts.urls')))
+
+    if base_module.is_newsletter_enabled():
+        patterns.append(path('cfg/newsletter/', include('django_cfg.apps.newsletter.urls')))
+
+    if base_module.is_leads_enabled():
+        patterns.append(path('cfg/leads/', include('django_cfg.apps.leads.urls')))
+
+    if base_module.is_knowbase_enabled():
+        patterns.append(path('cfg/knowbase/', include('django_cfg.apps.knowbase.urls')))
+
+    if base_module.is_agents_enabled():
+        patterns.append(path('cfg/agents/', include('django_cfg.apps.agents.urls')))
+
+    if base_module.should_enable_tasks():
+        patterns.append(path('cfg/tasks/', include('django_cfg.apps.tasks.urls')))
+        patterns.append(path('cfg/tasks/admin/', include('django_cfg.apps.tasks.urls_admin')))
+
+    if base_module.is_payments_enabled():
+        patterns.append(path('cfg/payments/', include('django_cfg.apps.payments.urls')))
+        patterns.append(path('cfg/payments/admin/', include('django_cfg.apps.payments.urls_admin')))
+
+    # Standalone apps
+    if base_module.is_maintenance_enabled():
+        patterns.append(
+            path('admin/django_cfg_maintenance/', include('django_cfg.apps.maintenance.urls_admin'))
+        )
+
+    if base_module.is_rpc_enabled():
+        patterns.append(path('rpc/', include('django_cfg.modules.django_ipc_client.dashboard.urls')))
+        patterns.append(path('admin/rpc/', include('django_cfg.modules.django_ipc_client.dashboard.urls_admin')))
+
+
 def get_django_cfg_urlpatterns() -> List[URLPattern]:
     """
-    Get Django CFG URL patterns based on enabled applications.
-    
+    Get Django CFG URL patterns based on OpenAPI groups.
+
     Returns:
-        List of URL patterns for enabled django_cfg applications
+        List of URL patterns for django_cfg
     """
-    from django_cfg.modules.base import BaseCfgModule
-    
     patterns = [
         # Core APIs (always enabled)
         path('health/', include('django_cfg.apps.api.health.urls')),
         path('endpoints/', include('django_cfg.apps.api.endpoints.urls')),
         path('commands/', include('django_cfg.apps.api.commands.urls')),
-        
+
+        # OpenAPI schemas (if enabled)
+        # Provides /openapi/{group}/schema/
+        path('openapi/', include('django_cfg.modules.django_client.urls')),
     ]
-    
+
     try:
-        # Use BaseModule to check enabled applications
-        base_module = BaseCfgModule()
-        
-        # All business logic apps are handled by Django Revolution zones
-        # to maintain consistency and enable client generation
-        # if base_module.is_support_enabled():
-        #     patterns.append(path('support/', include('django_cfg.apps.support.urls')))
-        # 
-        # if base_module.is_accounts_enabled():
-        #     patterns.append(path('accounts/', include('django_cfg.apps.accounts.urls')))
-        
-        # Newsletter and Leads are handled by Django Revolution zones
-        # to avoid URL namespace conflicts and enable client generation
-        # if base_module.is_newsletter_enabled():
-        #     patterns.append(path('newsletter/', include('django_cfg.apps.newsletter.urls')))
-        # 
-        # if base_module.is_leads_enabled():
-        #     patterns.append(path('leads/', include('django_cfg.apps.leads.urls')))
-        
-        # Tasks app - enabled when knowbase or agents are enabled
-        if base_module.should_enable_tasks():
-            patterns.append(path('admin/django_cfg_tasks/admin/', include('django_cfg.apps.tasks.urls_admin')))
-        
-        # Maintenance app - multi-site maintenance mode with Cloudflare
-        # if base_module.is_maintenance_enabled():
-        #     patterns.append(path('admin/django_cfg_maintenance/', include('django_cfg.apps.maintenance.urls_admin')))
-
-        if base_module.is_payments_enabled():
-            patterns.append(path('admin/django_cfg_payments/admin/', include('django_cfg.apps.payments.urls_admin')))
-
-        # RPC Dashboard - WebSocket & RPC activity monitoring
-        if base_module.is_rpc_enabled():
-            patterns.append(path('admin/rpc/', include('django_cfg.modules.django_ipc_client.dashboard.urls_admin')))
+        # Auto-register from OpenAPI groups (preferred)
+        from django_cfg.modules.django_client.core import get_openapi_service
+        service = get_openapi_service()
+
+        if service and service.is_enabled():
+            _register_group_urls(patterns, service.get_groups())
+        else:
+            # Fallback: Use BaseCfgModule when OpenAPI disabled
+            _register_apps_fallback(patterns)
 
     except Exception:
-        # Fallback: include all URLs if config is not available
-        # Note: This fallback should not be needed in production
-        pass
-    
+        # Last resort fallback
+        _register_apps_fallback(patterns)
+
     return patterns
 
 

django_cfg/core/base/config_model.py

@@ -313,12 +313,12 @@ class DjangoConfig(BaseModel):
     # === API Configuration ===
     drf: Optional[DRFConfig] = Field(
         default=None,
-        description="Extended Django REST Framework configuration (supplements Revolution)",
+        description="Extended Django REST Framework configuration (supplements OpenAPI Client)",
     )
 
     spectacular: Optional[SpectacularConfig] = Field(
         default=None,
-        description="Extended DRF Spectacular configuration (supplements Revolution)",
+        description="Extended DRF Spectacular configuration (supplements OpenAPI Client)",
     )
 
     # === Limits Configuration ===

django_cfg/core/constants.py

@@ -42,7 +42,7 @@ DEFAULT_APPS: List[str] = [
     "constance.backends.database",
     # Django CFG Core
     "django_cfg",
-    "django_revolution",
+    "django_cfg.modules.django_client",
 ]
 
 # Default middleware stack

django_cfg/core/generation/integration_generators/__init__.py

@@ -4,7 +4,7 @@ Integration generators module.
 Contains generators for third-party integrations and frameworks:
 - Session configuration
 - External services (Telegram, Unfold, Constance)
-- API frameworks (JWT, DRF, Spectacular, Revolution)
+- API frameworks (JWT, DRF, Spectacular, OpenAPI Client)
 - Background tasks (Dramatiq)
 """
 

django_cfg/core/generation/integration_generators/api.py

@@ -1,7 +1,7 @@
 """
 API frameworks generator.
 
-Handles JWT, DRF, Spectacular, and Django Revolution configuration.
+Handles JWT, DRF, Spectacular, and Django Client (OpenAPI) configuration.
 Size: ~250 lines (focused on API frameworks)
 """
 
@@ -20,7 +20,7 @@ class APIFrameworksGenerator:
 
     Responsibilities:
     - JWT authentication configuration
-    - Django Revolution framework
+    - Django Client (OpenAPI) framework
     - Django REST Framework (DRF)
     - DRF Spectacular (OpenAPI/Swagger)
     - Auto-configuration and extensions
@@ -56,7 +56,7 @@ class APIFrameworksGenerator:
 
         # Generate settings for each API framework
         settings.update(self._generate_jwt_settings())
-        settings.update(self._generate_revolution_settings())
+        settings.update(self._generate_openapi_client_settings())
         settings.update(self._apply_drf_spectacular_extensions())
 
         return settings
@@ -74,71 +74,104 @@ class APIFrameworksGenerator:
         jwt_settings = self.config.jwt.to_django_settings(self.config.secret_key)
         return jwt_settings
 
-    def _generate_revolution_settings(self) -> Dict[str, Any]:
+    def _generate_openapi_client_settings(self) -> Dict[str, Any]:
         """
-        Generate Django Revolution framework settings.
+        Generate Django Client (OpenAPI) framework settings.
 
         Returns:
-            Dictionary with Revolution and auto-generated DRF configuration
+            Dictionary with OpenAPI configuration and auto-generated DRF configuration
         """
-        if not hasattr(self.config, "revolution") or not self.config.revolution:
+        if not hasattr(self.config, "openapi_client") or not self.config.openapi_client:
             return {}
 
         settings = {}
 
-        # Revolution configuration
-        revolution_settings = {
-            "DJANGO_REVOLUTION": {
-                "api_prefix": self.config.revolution.api_prefix,
-                "debug": getattr(self.config.revolution, "debug", self.config.debug),
-                "auto_install_deps": getattr(self.config.revolution, "auto_install_deps", True),
-                "zones": {
-                    zone_name: zone_config.model_dump()
-                    for zone_name, zone_config in self.config.revolution.get_zones_with_defaults().items()
-                },
-            }
+        # OpenAPI Client configuration
+        openapi_settings = {
+            "OPENAPI_CLIENT": self.config.openapi_client.model_dump(),
         }
-        settings.update(revolution_settings)
+        settings.update(openapi_settings)
 
-        # Auto-generate DRF configuration using Revolution's core_config
-        drf_settings = self._generate_drf_from_revolution()
+        # Auto-generate DRF configuration from OpenAPIClientConfig
+        drf_settings = self._generate_drf_from_openapi()
         if drf_settings:
             settings.update(drf_settings)
 
         return settings
 
-    def _generate_drf_from_revolution(self) -> Dict[str, Any]:
+    def _generate_drf_from_openapi(self) -> Dict[str, Any]:
         """
-        Generate DRF + Spectacular settings from Revolution config.
+        Generate DRF + Spectacular settings from OpenAPIClientConfig.
 
         Returns:
             Dictionary with DRF and Spectacular configuration
         """
         try:
-            from django_revolution import create_drf_spectacular_config
-
-            # Extract DRF parameters from RevolutionConfig
-            drf_kwargs = {
-                "title": getattr(self.config.revolution, "drf_title", "API"),
-                "description": getattr(self.config.revolution, "drf_description", "RESTful API"),
-                "version": getattr(self.config.revolution, "drf_version", "1.0.0"),
-                "schema_path_prefix": f"/{self.config.revolution.api_prefix}/",
-                "enable_browsable_api": getattr(self.config.revolution, "drf_enable_browsable_api", False),
-                "enable_throttling": getattr(self.config.revolution, "drf_enable_throttling", False),
+            # Extract DRF parameters from OpenAPIClientConfig
+            openapi_config = self.config.openapi_client
+
+            # Build REST_FRAMEWORK settings
+            rest_framework = {
+                "DEFAULT_SCHEMA_CLASS": "drf_spectacular.openapi.AutoSchema",
+                "DEFAULT_PAGINATION_CLASS": "django_cfg.middleware.pagination.DefaultPagination",
+                "PAGE_SIZE": 100,
+                "DEFAULT_RENDERER_CLASSES": [
+                    "rest_framework.renderers.JSONRenderer",
+                    "django_cfg.modules.django_drf_theme.renderers.TailwindBrowsableAPIRenderer",
+                ],
+            }
+
+            # Add authentication classes if not browsable
+            if not openapi_config.drf_enable_browsable_api:
+                rest_framework["DEFAULT_RENDERER_CLASSES"] = [
+                    "rest_framework.renderers.JSONRenderer",
+                ]
+
+            # Add throttling if enabled
+            if openapi_config.drf_enable_throttling:
+                rest_framework["DEFAULT_THROTTLE_CLASSES"] = [
+                    "rest_framework.throttling.AnonRateThrottle",
+                    "rest_framework.throttling.UserRateThrottle",
+                ]
+                rest_framework["DEFAULT_THROTTLE_RATES"] = {
+                    "anon": "100/day",
+                    "user": "1000/day",
+                }
+
+            # Build SPECTACULAR_SETTINGS
+            spectacular_settings = {
+                "TITLE": openapi_config.drf_title,
+                "DESCRIPTION": openapi_config.drf_description,
+                "VERSION": openapi_config.drf_version,
+                "SERVE_INCLUDE_SCHEMA": openapi_config.drf_serve_include_schema,
+                "SCHEMA_PATH_PREFIX": openapi_config.get_drf_schema_path_prefix(),
+                "SWAGGER_UI_SETTINGS": {
+                    "deepLinking": True,
+                    "persistAuthorization": True,
+                    "displayOperationId": True,
+                },
+                "COMPONENT_SPLIT_REQUEST": True,
+                "COMPONENT_SPLIT_PATCH": True,
+                # Auto-fix enum naming collisions
+                "POSTPROCESSING_HOOKS": [
+                    "django_cfg.modules.django_client.spectacular.auto_fix_enum_names",
+                ],
             }
 
-            # Create DRF + Spectacular config with Revolution's comprehensive settings
-            drf_settings = create_drf_spectacular_config(**drf_kwargs)
+            drf_settings = {
+                "REST_FRAMEWORK": rest_framework,
+                "SPECTACULAR_SETTINGS": spectacular_settings,
+            }
 
-            logger.info("🚀 Generated DRF + Spectacular settings using Revolution's create_drf_spectacular_config")
+            logger.info("🚀 Generated DRF + Spectacular settings from OpenAPIClientConfig")
+            logger.info("   - Pagination: django_cfg.middleware.pagination.DefaultPagination")
+            logger.info("   - Renderer: TailwindBrowsableAPIRenderer")
+            logger.info(f"   - API: {openapi_config.drf_title} v{openapi_config.drf_version}")
 
             return drf_settings
 
-        except ImportError as e:
-            logger.warning(f"Could not import django_revolution.create_drf_spectacular_config: {e}")
-            return {}
         except Exception as e:
-            logger.warning(f"Could not generate DRF config from Revolution: {e}")
+            logger.warning(f"Could not generate DRF config from OpenAPIClientConfig: {e}")
             return {}
 
     def _apply_drf_spectacular_extensions(self) -> Dict[str, Any]:
@@ -175,7 +208,7 @@ class APIFrameworksGenerator:
         Returns:
             Dictionary with Spectacular settings
         """
-        # Check if Spectacular settings exist (from Revolution or elsewhere)
+        # Check if Spectacular settings exist (from OpenAPI Client or elsewhere)
         if not hasattr(self, '_has_spectacular_settings'):
             return {}
 
@@ -205,9 +238,17 @@ class APIFrameworksGenerator:
         """
         Apply DRF settings extensions.
 
+        Note: This method should NOT overwrite existing REST_FRAMEWORK settings.
+        It should only add missing settings or extend existing ones.
+
         Returns:
             Dictionary with DRF settings
         """
+        # Don't override if OpenAPIClientConfig already created full DRF config
+        if hasattr(self.config, 'openapi_client') and self.config.openapi_client:
+            logger.info("🔧 DRF settings already configured by OpenAPIClientConfig, skipping django-cfg extensions")
+            return {}
+
         settings = {}
 
         if self.config.drf: