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

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,81 +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", True),
-                "enable_throttling": getattr(self.config.revolution, "drf_enable_throttling", False),
-
-                # Django-CFG specific settings
-                "REST_FRAMEWORK_DEFAULT_PAGINATION_CLASS": "django_cfg.middleware.pagination.DefaultPagination",
-                "REST_FRAMEWORK_PAGE_SIZE": 100,
-                "REST_FRAMEWORK_DEFAULT_RENDERER_CLASSES": [
+            # 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",
                 ],
             }
 
-            # Create DRF + Spectacular config with Revolution's comprehensive settings
-            drf_settings = create_drf_spectacular_config(**drf_kwargs)
+            # 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",
+                ],
+            }
+
+            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]:
@@ -185,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 {}
 
@@ -221,9 +244,9 @@ class APIFrameworksGenerator:
         Returns:
             Dictionary with DRF settings
         """
-        # Don't override if Revolution already created full DRF config
-        if self.config.revolution:
-            logger.info("🔧 DRF settings already configured by Revolution, skipping django-cfg extensions")
+        # 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 = {}

django_cfg/core/integration/display/startup.py

@@ -160,8 +160,8 @@ class StartupDisplayManager(BaseDisplayManager):
             # App-specific configuration panels
             self._display_config_panels()
 
-            # Revolution info
-            self._display_revolution_info()
+            # OpenAPI Client info
+            self._display_openapi_client_info()
 
             # Management commands
             self._display_commands_info()
@@ -661,30 +661,38 @@ class StartupDisplayManager(BaseDisplayManager):
             print(f"❌ ERROR in _display_constance_summary: {e}")
             traceback.print_exc()
     
-    def _display_revolution_info(self):
-        """Display Django Revolution information."""
+    def _display_openapi_client_info(self):
+        """Display Django Client (OpenAPI) information."""
         try:
-            from django_revolution import get_revolution_info
-            revolution_info = get_revolution_info()
-            
-            revolution_table = self.create_table()
-            revolution_table.add_column("Setting", style="cyan", width=30)
-            revolution_table.add_column("Value", style="white")
-            
-            revolution_table.add_row("📦 Version", revolution_info.get('version', 'unknown'))
-            revolution_table.add_row("📊 Zones", str(revolution_info.get('zones_count', 0)))
-            revolution_table.add_row("📱 Apps", str(revolution_info.get('apps_count', 0)))
-            revolution_table.add_row("🔗 API Prefix", revolution_info.get('api_prefix', '/api/'))
-            
-            revolution_panel = self.create_panel(
-                revolution_table,
-                title="🚀 Django Revolution",
+            from django_cfg.modules.django_client.core.config.service import DjangoOpenAPI
+
+            service = DjangoOpenAPI.instance()
+            if not service.config or not service.config.enabled:
+                return
+
+            openapi_table = self.create_table()
+            openapi_table.add_column("Setting", style="cyan", width=30)
+            openapi_table.add_column("Value", style="white")
+
+            openapi_table.add_row("📦 Status", "[green]Enabled[/green]")
+            openapi_table.add_row("📊 Groups", str(len(service.config.groups)))
+            openapi_table.add_row("🔗 API Prefix", f"/{service.config.api_prefix}/")
+            openapi_table.add_row("📁 Output Dir", str(service.config.output_dir))
+
+            # List groups
+            group_names = [g.name for g in service.config.groups]
+            if group_names:
+                openapi_table.add_row("🏷️  Groups", ", ".join(group_names[:3]) + ("..." if len(group_names) > 3 else ""))
+
+            openapi_panel = self.create_panel(
+                openapi_table,
+                title="🚀 Django Client (OpenAPI)",
                 border_style="blue"
             )
-            
-            self.console.print(revolution_panel)
+
+            self.console.print(openapi_panel)
         except ImportError:
-            # Django Revolution not available
+            # Django Client not available
             pass
         except Exception:
             pass

django_cfg/core/integration/url_integration.py

@@ -16,7 +16,7 @@ def add_django_cfg_urls(urlpatterns: List[URLPattern], cfg_prefix: str = "cfg/")
     
     This function adds:
     - Django CFG management URLs (cfg/)
-    - Django Revolution URLs (if available)
+    - Django Client URLs (if available)
     - Startup information display (based on config)
     
     Args:
@@ -37,22 +37,16 @@ def add_django_cfg_urls(urlpatterns: List[URLPattern], cfg_prefix: str = "cfg/")
         
         # Automatically adds:
         # - path("cfg/", include("django_cfg.apps.urls"))
-        # - Django Revolution URLs (if available)
+        # - Django Client URLs (if available)
         # - Startup info display (based on config.startup_info_mode)
         urlpatterns = add_django_cfg_urls(urlpatterns)
     """
     # Add django_cfg API URLs
+    # Note: Django Client URLs are included in django_cfg.apps.urls
+    # at /cfg/openapi/{group}/schema/ to avoid conflicts
     new_patterns = urlpatterns + [
         path(cfg_prefix, include("django_cfg.apps.urls")),
     ]
-    
-    # Try to add Django Revolution URLs if available
-    try:
-        from django_revolution import add_revolution_urls
-        new_patterns = add_revolution_urls(new_patterns)
-    except ImportError:
-        # Django Revolution not available - skip
-        pass
 
     # Add django-browser-reload URLs in development (if installed)
     if settings.DEBUG:
@@ -122,13 +116,18 @@ def get_django_cfg_urls_info() -> dict:
         }
     }
     
-    # Add Django Revolution info if available
+    # Add Django Client info if available
     try:
-        from django_revolution import get_revolution_urls_info
-        revolution_info = get_revolution_urls_info()
-        if revolution_info:
-            info["django_revolution"] = revolution_info
+        from django_cfg.modules.django_client.core.config.service import DjangoOpenAPI
+        service = DjangoOpenAPI.instance()
+        if service.config and service.config.enabled:
+            info["django_client"] = {
+                "enabled": True,
+                "groups": len(service.config.groups),
+                "base_url": service.config.base_url,
+                "output_dir": service.config.output_dir,
+            }
     except ImportError:
         pass
-    
+
     return info