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

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",
+        )

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

@@ -0,0 +1,182 @@
+"""
+Python Generator - Main orchestrator for Python client generation.
+
+Coordinates all sub-generators:
+- ModelsGenerator: Pydantic models and enums
+- OperationsGenerator: Operation methods (async/sync)
+- AsyncClientGenerator: Async client classes
+- SyncClientGenerator: Sync client classes
+- FilesGenerator: Auxiliary files (__init__.py, logger, schema)
+"""
+
+from __future__ import annotations
+
+import pathlib
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+
+from ..base import BaseGenerator, GeneratedFile
+from ...ir import IROperationObject, IRSchemaObject
+
+from .models_generator import ModelsGenerator
+from .operations_generator import OperationsGenerator
+from .async_client_gen import AsyncClientGenerator
+from .sync_client_gen import SyncClientGenerator
+from .files_generator import FilesGenerator
+
+
+class PythonGenerator(BaseGenerator):
+    """
+    Python client generator.
+
+    Generates:
+    - models.py: Pydantic 2 models (User, UserRequest, PatchedUser)
+    - enums.py: Enum classes (StatusEnum, RoleEnum)
+    - client.py: AsyncClient with all operations
+    - sync_client.py: SyncClient with all operations
+    - __init__.py: Package exports
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        # Setup Jinja2 environment
+        templates_dir = pathlib.Path(__file__).parent / "templates"
+        self.jinja_env = Environment(
+            loader=FileSystemLoader(str(templates_dir)),
+            autoescape=select_autoescape(['html', 'xml']),
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+
+        # Initialize sub-generators
+        self.models_gen = ModelsGenerator(self.jinja_env, self.context, self)
+        self.operations_gen = OperationsGenerator(self.jinja_env, self)
+        self.async_client_gen = AsyncClientGenerator(self.jinja_env, self.context, self, self.operations_gen)
+        self.sync_client_gen = SyncClientGenerator(self.jinja_env, self, self.operations_gen)
+        self.files_gen = FilesGenerator(self.jinja_env, self.context, self)
+
+    def generate(self) -> list[GeneratedFile]:
+        """Generate all Python client files."""
+        files = []
+
+        if self.client_structure == "namespaced":
+            # Generate per-app folders
+            ops_by_tag = self.group_operations_by_tag()
+
+            for tag, operations in sorted(ops_by_tag.items()):
+                # Generate app folder (models.py, client.py, sync_client.py, __init__.py)
+                files.extend(self._generate_app_folder(tag, operations))
+
+            # Generate shared enums.py (Variant 2: all enums in root)
+            all_schemas = self.context.schemas
+            all_enums = self._collect_enums_from_schemas(all_schemas)
+            if all_enums:
+                files.append(self.models_gen.generate_shared_enums_file(all_enums))
+
+            # Generate main async client.py
+            files.append(self.async_client_gen.generate_main_client_file(ops_by_tag))
+
+            # Generate main sync client.py
+            files.append(self.sync_client_gen.generate_sync_main_client_file(ops_by_tag))
+
+            # Generate main __init__.py
+            files.append(self.files_gen.generate_main_init_file())
+
+            # Generate logger.py with Rich
+            files.append(self.files_gen.generate_logger_file())
+
+            # Generate retry.py with tenacity
+            files.append(self.files_gen.generate_retry_file())
+
+            # Generate schema.py with OpenAPI schema
+            if self.openapi_schema:
+                files.append(self.files_gen.generate_schema_file(self.openapi_schema))
+        else:
+            # Flat structure (original logic)
+            files.append(self.models_gen.generate_models_file())
+
+            enum_schemas = self.get_enum_schemas()
+            if enum_schemas:
+                files.append(self.models_gen.generate_enums_file())
+
+            files.append(self.async_client_gen.generate_client_file())
+            files.append(self.files_gen.generate_init_file())
+
+            # Generate logger.py with Rich
+            files.append(self.files_gen.generate_logger_file())
+
+            # Generate retry.py with tenacity
+            files.append(self.files_gen.generate_retry_file())
+
+            # Generate schema.py with OpenAPI schema
+            if self.openapi_schema:
+                files.append(self.files_gen.generate_schema_file(self.openapi_schema))
+
+        # Generate package files if requested
+        if self.generate_package_files:
+            files.append(self.files_gen.generate_pyproject_toml_file(self.package_config))
+
+        return files
+
+    def _generate_app_folder(self, tag: str, operations: list[IROperationObject]) -> list[GeneratedFile]:
+        """Generate folder for a specific app (tag)."""
+        files = []
+
+        # Get schemas used by this app
+        app_schemas = self._get_schemas_for_operations(operations)
+
+        # Generate models.py for this app
+        files.append(self.models_gen.generate_app_models_file(tag, app_schemas, operations))
+
+        # Generate async client.py for this app
+        files.append(self.async_client_gen.generate_app_client_file(tag, operations))
+
+        # Generate sync client.py for this app
+        files.append(self.sync_client_gen.generate_app_sync_client_file(tag, operations))
+
+        # Generate __init__.py for this app
+        files.append(self.files_gen.generate_app_init_file(tag, operations))
+
+        return files
+
+    def _get_schemas_for_operations(self, operations: list[IROperationObject]) -> dict[str, IRSchemaObject]:
+        """Get all schemas used by given operations."""
+        schemas = {}
+
+        for operation in operations:
+            # Request body schemas
+            if operation.request_body and operation.request_body.schema_name:
+                schema_name = operation.request_body.schema_name
+                if schema_name in self.context.schemas:
+                    schemas[schema_name] = self.context.schemas[schema_name]
+
+            # Patch request body schemas
+            if operation.patch_request_body and operation.patch_request_body.schema_name:
+                schema_name = operation.patch_request_body.schema_name
+                if schema_name in self.context.schemas:
+                    schemas[schema_name] = self.context.schemas[schema_name]
+
+            # Response schemas
+            for status_code, response in operation.responses.items():
+                if response.schema_name:
+                    if response.schema_name in self.context.schemas:
+                        schemas[response.schema_name] = self.context.schemas[response.schema_name]
+
+        return schemas
+
+    # Backward compatibility - delegate to sub-generators
+    def generate_schema(self, schema: IRSchemaObject) -> str:
+        """Generate Pydantic model for schema (delegates to ModelsGenerator)."""
+        return self.models_gen.generate_schema(schema)
+
+    def generate_enum(self, schema: IRSchemaObject) -> str:
+        """Generate Enum class (delegates to ModelsGenerator)."""
+        return self.models_gen.generate_enum(schema)
+
+    def generate_operation(self, operation: IROperationObject, remove_tag_prefix: bool = False) -> str:
+        """Generate async method for operation (delegates to OperationsGenerator)."""
+        return self.operations_gen.generate_async_operation(operation, remove_tag_prefix)
+
+    def generate_sync_operation(self, operation: IROperationObject, remove_tag_prefix: bool = False) -> str:
+        """Generate sync method for operation (delegates to OperationsGenerator)."""
+        return self.operations_gen.generate_sync_operation(operation, remove_tag_prefix)