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

django_cfg/core/generation/integration_generators/api.py

@@ -152,9 +152,10 @@ class APIFrameworksGenerator:
                 },
                 "COMPONENT_SPLIT_REQUEST": True,
                 "COMPONENT_SPLIT_PATCH": True,
-                # Auto-fix enum naming collisions
+                # Postprocessing hooks
                 "POSTPROCESSING_HOOKS": [
                     "django_cfg.modules.django_client.spectacular.auto_fix_enum_names",
+                    "django_cfg.modules.django_client.spectacular.mark_async_operations",
                 ],
             }
 

django_cfg/models/django/openapi.py

@@ -8,11 +8,11 @@ This replaces django-revolution with a cleaner, faster, type-safe implementation
 """
 
 from typing import Dict, Any, Optional
-from pydantic import BaseModel, Field
+from pydantic import Field
 from django_cfg.modules.django_client.core.config import OpenAPIConfig, OpenAPIGroupConfig
 
 
-class ExtendedOpenAPIConfig(OpenAPIConfig):
+class OpenAPIClientConfig(OpenAPIConfig):
     """
     Extended OpenAPI configuration with DRF parameters for django-cfg integration.
 
@@ -21,9 +21,9 @@ class ExtendedOpenAPIConfig(OpenAPIConfig):
 
     Example:
         ```python
-        from django_cfg import ExtendedOpenAPIConfig, OpenAPIGroupConfig
+        from django_cfg import OpenAPIClientConfig, OpenAPIGroupConfig
 
-        config = ExtendedOpenAPIConfig(
+        config = OpenAPIClientConfig(
             enabled=True,
             groups=[
                 OpenAPIGroupConfig(
@@ -153,86 +153,10 @@ class ExtendedOpenAPIConfig(OpenAPIConfig):
                     description="All django-cfg built-in applications",
                 )
 
-            # Skip individual cfg_* groups - use unified 'cfg' instead
             return groups_dict
 
-            # Add Support group if enabled
-            if support_enabled and 'cfg_support' not in groups_dict:
-                groups_dict['cfg_support'] = OpenAPIGroupConfig(
-                    name="cfg_support",
-                    apps=["django_cfg.apps.support"],
-                    title="Support API",
-                    description="Support tickets and messages API",
-                )
-
-            # Add Accounts group if enabled
-            if accounts_enabled and 'cfg_accounts' not in groups_dict:
-                groups_dict['cfg_accounts'] = OpenAPIGroupConfig(
-                    name="cfg_accounts",
-                    apps=["django_cfg.apps.accounts"],
-                    title="Accounts API",
-                    description="User management, OTP, profiles, and activity tracking API",
-                )
-
-            # Add Newsletter group if enabled
-            if newsletter_enabled and 'cfg_newsletter' not in groups_dict:
-                groups_dict['cfg_newsletter'] = OpenAPIGroupConfig(
-                    name="cfg_newsletter",
-                    apps=["django_cfg.apps.newsletter"],
-                    title="Newsletter API",
-                    description="Email campaigns, subscriptions, and newsletter management API",
-                )
-
-            # Add Leads group if enabled
-            if leads_enabled and 'cfg_leads' not in groups_dict:
-                groups_dict['cfg_leads'] = OpenAPIGroupConfig(
-                    name="cfg_leads",
-                    apps=["django_cfg.apps.leads"],
-                    title="Leads API",
-                    description="Lead collection, contact forms, and CRM integration API",
-                )
-
-            # Add Knowbase group if enabled
-            if knowbase_enabled and 'cfg_knowbase' not in groups_dict:
-                groups_dict['cfg_knowbase'] = OpenAPIGroupConfig(
-                    name="cfg_knowbase",
-                    apps=["django_cfg.apps.knowbase"],
-                    title="Knowbase API",
-                    description="Knowledge base, AI chat, embeddings, and search API",
-                )
-
-            # Add Agents group if enabled
-            if agents_enabled and 'cfg_agents' not in groups_dict:
-                groups_dict['cfg_agents'] = OpenAPIGroupConfig(
-                    name="cfg_agents",
-                    apps=["django_cfg.apps.agents"],
-                    title="Agents API",
-                    description="Agent definitions, executions, workflows, and tools API",
-                )
-
-            # Add Tasks group if enabled
-            if tasks_enabled and 'cfg_tasks' not in groups_dict:
-                groups_dict['cfg_tasks'] = OpenAPIGroupConfig(
-                    name="cfg_tasks",
-                    apps=["django_cfg.apps.tasks"],
-                    title="Tasks API",
-                    description="Tasks, workflows, and automation API",
-                )
-
-            # Add Payments group if enabled
-            if payments_enabled and 'cfg_payments' not in groups_dict:
-                groups_dict['cfg_payments'] = OpenAPIGroupConfig(
-                    name="cfg_payments",
-                    apps=["django_cfg.apps.payments"],
-                    title="Payments API",
-                    description="Payments, subscriptions, and billing API",
-                )
-
         except Exception:
             pass
 
         return groups_dict
 
-
-# Alias for easier import
-OpenAPIClientConfig = ExtendedOpenAPIConfig

django_cfg/modules/django_client/core/archive/manager.py

@@ -57,12 +57,12 @@ class ArchiveManager:
 
         if python_dir and python_dir.exists():
             dest = archive_path / "python"
-            shutil.copytree(python_dir, dest)
+            shutil.copytree(python_dir, dest, dirs_exist_ok=True)
             copied["python"] = str(dest)
 
         if typescript_dir and typescript_dir.exists():
             dest = archive_path / "typescript"
-            shutil.copytree(typescript_dir, dest)
+            shutil.copytree(typescript_dir, dest, dirs_exist_ok=True)
             copied["typescript"] = str(dest)
 
         # Create metadata

django_cfg/modules/django_client/core/config/config.py

@@ -76,6 +76,26 @@ class OpenAPIConfig(BaseModel):
         description="Generate TypeScript client",
     )
 
+    generate_package_files: bool = Field(
+        default=False,
+        description="Generate package.json (TypeScript) and pyproject.toml (Python)",
+    )
+
+    generate_zod_schemas: bool = Field(
+        default=False,
+        description="Generate Zod schemas for runtime validation (TypeScript only)",
+    )
+
+    generate_fetchers: bool = Field(
+        default=False,
+        description="Generate typed fetcher functions (TypeScript only, requires Zod schemas)",
+    )
+
+    generate_swr_hooks: bool = Field(
+        default=False,
+        description="Generate SWR hooks for React (TypeScript only, requires fetchers)",
+    )
+
     client_structure: Literal["flat", "namespaced"] = Field(
         default="namespaced",
         description=(

django_cfg/modules/django_client/core/config/service.py

@@ -59,7 +59,7 @@ class DjangoOpenAPI:
         if not self.config:
             return {}
 
-        # Use get_groups_with_defaults if available (ExtendedOpenAPIConfig)
+        # Use get_groups_with_defaults if available (OpenAPIClientConfig)
         if hasattr(self.config, 'get_groups_with_defaults'):
             return self.config.get_groups_with_defaults()
 

django_cfg/modules/django_client/core/generator/__init__.py

@@ -22,10 +22,10 @@ Usage:
 from pathlib import Path
 from typing import Literal
 
-from django_cfg.modules.django_client.core.generator.base import GeneratedFile
-from django_cfg.modules.django_client.core.generator.python import PythonGenerator
-from django_cfg.modules.django_client.core.generator.typescript import TypeScriptGenerator
-from django_cfg.modules.django_client.core.ir import IRContext
+from .base import GeneratedFile
+from .python import PythonGenerator
+from .typescript import TypeScriptGenerator
+from ..ir import IRContext
 
 __all__ = [
     "PythonGenerator",

django_cfg/modules/django_client/core/generator/base.py

@@ -48,6 +48,11 @@ class BaseGenerator(ABC):
         client_structure: str = "namespaced",
         openapi_schema: dict | None = None,
         tag_prefix: str = "",
+        package_config: dict | None = None,
+        generate_package_files: bool = False,
+        generate_zod_schemas: bool = False,
+        generate_fetchers: bool = False,
+        generate_swr_hooks: bool = False,
     ):
         """
         Initialize generator with IR context.
@@ -57,11 +62,21 @@ class BaseGenerator(ABC):
             client_structure: Client structure ("flat" or "namespaced")
             openapi_schema: OpenAPI schema dict (for embedding in client)
             tag_prefix: Prefix to add to all tag names (e.g., "cfg_")
+            package_config: Package configuration (name, version, author, etc.)
+            generate_package_files: Whether to generate package.json/pyproject.toml
+            generate_zod_schemas: Whether to generate Zod schemas (TypeScript only)
+            generate_fetchers: Whether to generate typed fetchers (TypeScript only)
+            generate_swr_hooks: Whether to generate SWR hooks (TypeScript only, React)
         """
         self.context = context
         self.client_structure = client_structure
         self.openapi_schema = openapi_schema
         self.tag_prefix = tag_prefix
+        self.package_config = package_config or {}
+        self.generate_package_files = generate_package_files
+        self.generate_zod_schemas = generate_zod_schemas
+        self.generate_fetchers = generate_fetchers
+        self.generate_swr_hooks = generate_swr_hooks
 
     # ===== Namespaced Structure Helpers =====
 
@@ -765,3 +780,59 @@ class BaseGenerator(ABC):
             lines.append(" ".join(current_line))
 
         return lines
+
+    def format_enum_description(self, text: str) -> str:
+        """
+        Format enum description by splitting bullet points.
+
+        Enum descriptions from OpenAPI often have the format:
+        "* `value1` - Desc1 * `value2` - Desc2"
+
+        This method splits them into separate lines:
+        "* `value1` - Desc1\n* `value2` - Desc2"
+
+        Args:
+            text: Enum description text
+
+        Returns:
+            Formatted description with proper line breaks
+        """
+        if not text:
+            return text
+
+        # Split by " * `" pattern (preserving the first *)
+        import re
+        # Replace " * `" with newline + "* `"
+        formatted = re.sub(r'\s+\*\s+`', '\n* `', text.strip())
+
+        return formatted
+
+    def sanitize_enum_name(self, name: str) -> str:
+        """
+        Sanitize enum name by converting to PascalCase.
+
+        Examples:
+            "OrderDetail.status" -> "OrderDetailStatus"
+            "Currency.currency_type" -> "CurrencyCurrencyType"
+            "CurrencyList.currency_type" -> "CurrencyListCurrencyType"
+            "User.role" -> "UserRole"
+
+        Args:
+            name: Original enum name (may contain dots, underscores)
+
+        Returns:
+            Sanitized PascalCase name
+        """
+        # Replace dots with underscores, then split and convert to PascalCase
+        parts = name.replace('.', '_').split('_')
+        result = []
+        for word in parts:
+            if not word:
+                continue
+            # If word is already PascalCase/camelCase, keep it as is
+            # Otherwise capitalize first letter only
+            if word[0].isupper():
+                result.append(word)
+            else:
+                result.append(word[0].upper() + word[1:] if len(word) > 1 else word.upper())
+        return ''.join(result)

django_cfg/modules/django_client/core/generator/python/__init__.py

@@ -0,0 +1,16 @@
+"""
+Python Generator - Generates Python client (Pydantic 2 + httpx).
+
+This generator creates a complete Python API client from IR:
+- Pydantic 2 models (Request/Response/Patch splits)
+- Enum classes from x-enum-varnames
+- httpx.AsyncClient for async HTTP
+- Django CSRF/session handling
+- Type-safe (MyPy strict mode compatible)
+
+Reference: https://docs.pydantic.dev/latest/
+"""
+
+from .generator import PythonGenerator
+
+__all__ = ['PythonGenerator']

django_cfg/modules/django_client/core/generator/python/async_client_gen.py

@@ -0,0 +1,174 @@
+"""
+Async Client Generator - Generates async Python clients.
+
+Handles:
+- Main APIClient class (httpx.AsyncClient)
+- Sub-client classes (per tag/app)
+- Flat vs namespaced structures
+"""
+
+from __future__ import annotations
+
+from jinja2 import Environment
+
+from ..base import GeneratedFile
+from ...ir import IROperationObject
+
+
+class AsyncClientGenerator:
+    """Generates async Python client files."""
+
+    def __init__(self, jinja_env: Environment, context, base_generator, operations_gen):
+        """
+        Initialize async client generator.
+
+        Args:
+            jinja_env: Jinja2 environment for templates
+            context: Generation context
+            base_generator: Reference to base generator
+            operations_gen: Operations generator instance
+        """
+        self.jinja_env = jinja_env
+        self.context = context
+        self.base = base_generator
+        self.operations_gen = operations_gen
+
+    def generate_client_file(self) -> GeneratedFile:
+        """Generate client.py with AsyncClient."""
+        # Client class
+        client_code = self._generate_client_class()
+
+        template = self.jinja_env.get_template('client_file.py.jinja')
+        content = template.render(
+            has_enums=bool(self.base.get_enum_schemas()),
+            client_code=client_code
+        )
+
+        return GeneratedFile(
+            path="client.py",
+            content=content,
+            description="AsyncClient with httpx",
+        )
+
+    def _generate_client_class(self) -> str:
+        """Generate APIClient class."""
+        if self.base.client_structure == "namespaced":
+            return self._generate_namespaced_client()
+        else:
+            return self._generate_flat_client()
+
+    def _generate_flat_client(self) -> str:
+        """Generate flat APIClient (all methods in one class)."""
+        # Generate all operation methods
+        method_codes = []
+        for op_id, operation in self.context.operations.items():
+            method_codes.append(self.operations_gen.generate_async_operation(operation))
+
+        template = self.jinja_env.get_template('client/flat_client.py.jinja')
+        return template.render(
+            api_title=self.context.openapi_info.title,
+            operations=method_codes
+        )
+
+    def _generate_namespaced_client(self) -> str:
+        """Generate namespaced APIClient (sub-clients per tag)."""
+        # Group operations by tag (using base class method)
+        ops_by_tag = self.base.group_operations_by_tag()
+
+        # Generate sub-client classes
+        sub_client_classes = []
+        for tag, operations in sorted(ops_by_tag.items()):
+            sub_client_classes.append(self._generate_sub_client_class(tag, operations))
+
+        sub_clients_code = "\n\n\n".join(sub_client_classes)
+
+        # Generate main APIClient
+        main_client_code = self._generate_main_client_class(ops_by_tag)
+
+        return f"{sub_clients_code}\n\n\n{main_client_code}"
+
+    def _generate_sub_client_class(self, tag: str, operations: list) -> str:
+        """Generate sub-client class for a specific tag."""
+        class_name = self.base.tag_to_class_name(tag)
+
+        # Generate methods for this tag
+        method_codes = []
+        for operation in operations:
+            method_codes.append(self.operations_gen.generate_async_operation(operation, remove_tag_prefix=True))
+
+        template = self.jinja_env.get_template('client/sub_client.py.jinja')
+        return template.render(
+            tag=self.base.tag_to_display_name(tag),
+            class_name=class_name,
+            operations=method_codes
+        )
+
+    def _generate_main_client_class(self, ops_by_tag: dict) -> str:
+        """Generate main APIClient with sub-clients."""
+        tags = sorted(ops_by_tag.keys())
+
+        # Prepare tags data for template
+        tags_data = [
+            {
+                "class_name": self.base.tag_to_class_name(tag),
+                "property": self.base.tag_to_property_name(tag),
+            }
+            for tag in tags
+        ]
+
+        template = self.jinja_env.get_template('client/main_client.py.jinja')
+        return template.render(
+            api_title=self.context.openapi_info.title,
+            tags=tags_data
+        )
+
+    def generate_app_client_file(self, tag: str, operations: list[IROperationObject]) -> GeneratedFile:
+        """Generate client.py for a specific app."""
+        class_name = self.base.tag_to_class_name(tag)
+
+        # Generate methods
+        method_codes = []
+        for operation in operations:
+            method_codes.append(self.operations_gen.generate_async_operation(operation, remove_tag_prefix=True))
+
+        template = self.jinja_env.get_template('client/app_client.py.jinja')
+        content = template.render(
+            tag=self.base.tag_to_display_name(tag),
+            class_name=class_name,
+            operations=method_codes
+        )
+
+        folder_name = self.base.tag_and_app_to_folder_name(tag, operations)
+        return GeneratedFile(
+            path=f"{folder_name}/client.py",
+            content=content,
+            description=f"API client for {tag}",
+        )
+
+    def generate_main_client_file(self, ops_by_tag: dict) -> GeneratedFile:
+        """Generate main client.py with APIClient."""
+        tags = sorted(ops_by_tag.keys())
+
+        # Prepare tags data for template
+        tags_data = [
+            {
+                "class_name": self.base.tag_to_class_name(tag),
+                "slug": self.base.tag_and_app_to_folder_name(tag, ops_by_tag[tag]),
+            }
+            for tag in tags
+        ]
+
+        # Generate main APIClient class
+        client_code = self._generate_main_client_class(ops_by_tag)
+
+        template = self.jinja_env.get_template('client/main_client_file.py.jinja')
+        content = template.render(
+            tags=tags_data,
+            client_code=client_code
+        )
+
+        return GeneratedFile(
+            path="client.py",
+            content=content,
+            description="Main API client",
+        )

django_cfg/modules/django_client/core/generator/python/files_generator.py

@@ -0,0 +1,180 @@
+"""
+Files Generator - Generates auxiliary files (__init__.py, logger.py, schema.py).
+
+Handles:
+- Package __init__.py files
+- Logger configuration
+- OpenAPI schema embedding
+- API wrapper classes
+"""
+
+from __future__ import annotations
+
+import json
+import re
+
+from jinja2 import Environment
+
+from ..base import GeneratedFile
+from ...ir import IROperationObject
+
+
+class FilesGenerator:
+    """Generates auxiliary Python files."""
+
+    def __init__(self, jinja_env: Environment, context, base_generator):
+        """
+        Initialize files generator.
+
+        Args:
+            jinja_env: Jinja2 environment for templates
+            context: Generation context
+            base_generator: Reference to base generator
+        """
+        self.jinja_env = jinja_env
+        self.context = context
+        self.base = base_generator
+
+    def generate_init_file(self) -> GeneratedFile:
+        """Generate __init__.py with exports (flat structure)."""
+        template = self.jinja_env.get_template('__init__.py.jinja')
+        content = template.render(
+            has_enums=bool(self.base.get_enum_schemas())
+        )
+
+        return GeneratedFile(
+            path="__init__.py",
+            content=content,
+            description="Package exports",
+        )
+
+    def generate_app_init_file(self, tag: str, operations: list[IROperationObject]) -> GeneratedFile:
+        """Generate __init__.py for a specific app."""
+        class_name = self.base.tag_to_class_name(tag)
+
+        template = self.jinja_env.get_template('app_init.py.jinja')
+        content = template.render(class_name=class_name)
+
+        folder_name = self.base.tag_and_app_to_folder_name(tag, operations)
+        return GeneratedFile(
+            path=f"{folder_name}/__init__.py",
+            content=content,
+            description=f"Package exports for {tag}",
+        )
+
+    def generate_main_init_file(self) -> GeneratedFile:
+        """Generate main __init__.py with API class and JWT management."""
+        ops_by_tag = self.base.group_operations_by_tag()
+        tags = sorted(ops_by_tag.keys())
+
+        # Prepare tags data for template
+        tags_data = [
+            {
+                "class_name": self.base.tag_to_class_name(tag),
+                "slug": self.base.tag_and_app_to_folder_name(tag, ops_by_tag[tag]),
+            }
+            for tag in tags
+        ]
+
+        # Check if we have enums
+        all_schemas = self.context.schemas
+        all_enums = self.base._collect_enums_from_schemas(all_schemas)
+
+        # API class
+        api_class = self.generate_api_wrapper_class_python(tags)
+
+        template = self.jinja_env.get_template('main_init.py.jinja')
+        content = template.render(
+            api_title=self.context.openapi_info.title,
+            tags=tags_data,
+            has_enums=bool(all_enums),
+            enum_names=sorted(all_enums.keys()) if all_enums else [],
+            api_class=api_class
+        )
+
+        return GeneratedFile(
+            path="__init__.py",
+            content=content,
+            description="Package exports with API class and JWT management",
+        )
+
+    def generate_api_wrapper_class_python(self, tags: list[str]) -> str:
+        """Generate API wrapper class with JWT management for Python."""
+        # Prepare property data
+        properties_data = []
+        for tag in tags:
+            properties_data.append({
+                "tag": tag,
+                "class_name": self.base.tag_to_class_name(tag),
+                "property": self.base.tag_to_property_name(tag),
+            })
+
+        template = self.jinja_env.get_template('api_wrapper.py.jinja')
+        return template.render(properties=properties_data)
+
+    def generate_logger_file(self) -> GeneratedFile:
+        """Generate logger.py with Rich integration."""
+        template = self.jinja_env.get_template('utils/logger.py.jinja')
+        content = template.render()
+
+        return GeneratedFile(
+            path="logger.py",
+            content=content,
+            description="API Logger with Rich",
+        )
+
+    def generate_retry_file(self) -> GeneratedFile:
+        """Generate retry.py with tenacity integration."""
+        template = self.jinja_env.get_template('utils/retry.py.jinja')
+        content = template.render()
+
+        return GeneratedFile(
+            path="retry.py",
+            content=content,
+            description="Retry utilities with tenacity",
+        )
+
+    def generate_pyproject_toml_file(self, package_config: dict = None) -> GeneratedFile:
+        """Generate pyproject.toml for Poetry/PyPI publishing."""
+        if package_config is None:
+            package_config = {}
+
+        # Default configuration
+        defaults = {
+            "package_name": package_config.get("name", "api-client"),
+            "version": package_config.get("version", "1.0.0"),
+            "description": package_config.get("description") or f"Auto-generated Python client for {self.context.openapi_info.title}",
+            "authors": package_config.get("authors", ["Author <author@example.com>"]),
+            "license": package_config.get("license", "MIT"),
+            "repository_url": package_config.get("repository_url"),
+            "keywords": package_config.get("keywords", ["api", "client", "python", "openapi"]),
+            "python_version": package_config.get("python_version", "^3.12"),
+        }
+
+        template = self.jinja_env.get_template('pyproject.toml.jinja')
+        content = template.render(**defaults)
+
+        return GeneratedFile(
+            path="pyproject.toml",
+            content=content,
+            description="Poetry package configuration",
+        )
+
+    def generate_schema_file(self, openapi_schema: dict) -> GeneratedFile:
+        """Generate schema.py with OpenAPI schema as dict."""
+        # First, convert to pretty JSON
+        schema_json = json.dumps(openapi_schema, indent=4, ensure_ascii=False)
+
+        # Convert JSON literals to Python literals
+        schema_json = re.sub(r'\btrue\b', 'True', schema_json)
+        schema_json = re.sub(r'\bfalse\b', 'False', schema_json)
+        schema_json = re.sub(r'\bnull\b', 'None', schema_json)
+
+        template = self.jinja_env.get_template('utils/schema.py.jinja')
+        content = template.render(schema_dict=schema_json)
+
+        return GeneratedFile(
+            path="schema.py",
+            content=content,
+            description="OpenAPI Schema",
+        )