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

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

@@ -0,0 +1,278 @@
+"""
+Operations Generator - Generates operation methods for async and sync clients.
+
+Handles:
+- Async operation methods (async def with await)
+- Sync operation methods (def without await)
+- Path parameters, query parameters, request bodies
+- Response parsing and validation
+"""
+
+from __future__ import annotations
+
+from jinja2 import Environment
+
+from ...ir import IROperationObject
+
+
+class OperationsGenerator:
+    """Generates operation methods for Python clients."""
+
+    def __init__(self, jinja_env: Environment, base_generator):
+        """
+        Initialize operations generator.
+
+        Args:
+            jinja_env: Jinja2 environment for templates
+            base_generator: Reference to base generator for utility methods
+        """
+        self.jinja_env = jinja_env
+        self.base = base_generator
+
+    def generate_async_operation(self, operation: IROperationObject, remove_tag_prefix: bool = False) -> str:
+        """Generate async method for operation."""
+        # Get method name
+        method_name = operation.operation_id
+        if remove_tag_prefix and operation.tags:
+            # Remove tag prefix using base class method
+            tag = operation.tags[0]
+            method_name = self.base.remove_tag_prefix(method_name, tag)
+
+        # Method signature
+        params = ["self"]
+
+        # Add path parameters
+        for param in operation.path_parameters:
+            param_type = self._map_param_type(param.schema_type)
+            params.append(f"{param.name}: {param_type}")
+
+        # Add request body parameter
+        if operation.request_body:
+            params.append(f"data: {operation.request_body.schema_name}")
+        elif operation.patch_request_body:
+            params.append(f"data: {operation.patch_request_body.schema_name} | None = None")
+
+        # Add query parameters
+        for param in operation.query_parameters:
+            param_type = self._map_param_type(param.schema_type)
+            if not param.required:
+                param_type = f"{param_type} | None = None"
+            params.append(f"{param.name}: {param_type}")
+
+        # Return type
+        primary_response = operation.primary_success_response
+        if primary_response and primary_response.schema_name:
+            if operation.is_list_operation:
+                return_type = f"list[{primary_response.schema_name}]"
+            else:
+                return_type = primary_response.schema_name
+        else:
+            return_type = "None"
+
+        signature = f"async def {method_name}({', '.join(params)}) -> {return_type}:"
+
+        # Docstring
+        docstring_lines = []
+        if operation.summary:
+            docstring_lines.append(operation.summary)
+        if operation.description:
+            if docstring_lines:
+                docstring_lines.append("")
+            docstring_lines.extend(self.base.wrap_comment(operation.description, 72))
+
+        docstring = "\n".join(docstring_lines) if docstring_lines else None
+
+        # Method body
+        body_lines = []
+
+        # Build URL
+        url_expr = f'"{operation.path}"'
+        if operation.path_parameters:
+            # Replace {id} with f-string {id}
+            url_expr = f'f"{operation.path}"'
+
+        body_lines.append(f"url = {url_expr}")
+
+        # Build request
+        request_kwargs = []
+
+        # Query params
+        if operation.query_parameters:
+            query_items = []
+            for param in operation.query_parameters:
+                if param.required:
+                    query_items.append(f'"{param.name}": {param.name}')
+                else:
+                    query_items.append(f'"{param.name}": {param.name} if {param.name} is not None else None')
+
+            query_dict = "{" + ", ".join(query_items) + "}"
+            request_kwargs.append(f"params={query_dict}")
+
+        # JSON body
+        if operation.request_body:
+            # Required body
+            request_kwargs.append("json=data.model_dump()")
+        elif operation.patch_request_body:
+            # Optional PATCH body - check for None
+            request_kwargs.append("json=data.model_dump() if data is not None else None")
+
+        # Make request
+        method_lower = operation.http_method.lower()
+        request_line = f"response = await self._client.{method_lower}(url"
+        if request_kwargs:
+            request_line += ", " + ", ".join(request_kwargs)
+        request_line += ")"
+
+        body_lines.append(request_line)
+
+        # Handle response
+        body_lines.append("response.raise_for_status()")
+
+        if return_type != "None":
+            if operation.is_list_operation:
+                # Paginated list response - extract results
+                body_lines.append(f"data = response.json()")
+                body_lines.append(f'return [{primary_response.schema_name}.model_validate(item) for item in data.get("results", [])]')
+            else:
+                body_lines.append(f"return {primary_response.schema_name}.model_validate(response.json())")
+        else:
+            body_lines.append("return None")
+
+        template = self.jinja_env.get_template('client/operation_method.py.jinja')
+        return template.render(
+            method_name=method_name,
+            params=params,
+            return_type=return_type,
+            docstring=docstring,
+            body_lines=body_lines
+        )
+
+    def generate_sync_operation(self, operation: IROperationObject, remove_tag_prefix: bool = False) -> str:
+        """Generate sync method for operation (mirrors async generate_operation)."""
+        # Get method name
+        method_name = operation.operation_id
+        if remove_tag_prefix and operation.tags:
+            # Remove tag prefix using base class method
+            tag = operation.tags[0]
+            method_name = self.base.remove_tag_prefix(method_name, tag)
+
+        # Method signature
+        params = ["self"]
+
+        # Add path parameters
+        for param in operation.path_parameters:
+            param_type = self._map_param_type(param.schema_type)
+            params.append(f"{param.name}: {param_type}")
+
+        # Add request body parameter
+        if operation.request_body:
+            params.append(f"data: {operation.request_body.schema_name}")
+        elif operation.patch_request_body:
+            params.append(f"data: {operation.patch_request_body.schema_name} | None = None")
+
+        # Add query parameters
+        for param in operation.query_parameters:
+            param_type = self._map_param_type(param.schema_type)
+            if not param.required:
+                param_type = f"{param_type} | None = None"
+            params.append(f"{param.name}: {param_type}")
+
+        # Return type
+        primary_response = operation.primary_success_response
+        if primary_response and primary_response.schema_name:
+            if operation.is_list_operation:
+                return_type = f"list[{primary_response.schema_name}]"
+            else:
+                return_type = primary_response.schema_name
+        else:
+            return_type = "None"
+
+        # Docstring
+        docstring_lines = []
+        if operation.summary:
+            docstring_lines.append(operation.summary)
+        if operation.description:
+            if docstring_lines:
+                docstring_lines.append("")
+            docstring_lines.extend(self.base.wrap_comment(operation.description, 72))
+
+        docstring = "\n".join(docstring_lines) if docstring_lines else None
+
+        # Method body
+        body_lines = []
+
+        # Build URL
+        url_expr = f'"{operation.path}"'
+        if operation.path_parameters:
+            # Replace {id} with f-string {id}
+            url_expr = f'f"{operation.path}"'
+
+        body_lines.append(f"url = {url_expr}")
+
+        # Build request
+        request_kwargs = []
+
+        # Query params
+        if operation.query_parameters:
+            query_items = []
+            for param in operation.query_parameters:
+                if param.required:
+                    query_items.append(f'"{param.name}": {param.name}')
+                else:
+                    query_items.append(f'"{param.name}": {param.name} if {param.name} is not None else None')
+
+            query_dict = "{" + ", ".join(query_items) + "}"
+            request_kwargs.append(f"params={query_dict}")
+
+        # JSON body
+        if operation.request_body:
+            # Required body
+            request_kwargs.append("json=data.model_dump(exclude_unset=True)")
+        elif operation.patch_request_body:
+            # Optional PATCH body - check for None
+            request_kwargs.append("json=data.model_dump(exclude_unset=True) if data is not None else None")
+
+        # HTTP method
+        method_lower = operation.http_method.lower()
+
+        # Build request call (sync version - no await)
+        if request_kwargs:
+            request_call = f'self._client.{method_lower}(url, {", ".join(request_kwargs)})'
+        else:
+            request_call = f'self._client.{method_lower}(url)'
+
+        body_lines.append(f"response = {request_call}")
+        body_lines.append("response.raise_for_status()")
+
+        # Parse response
+        if return_type != "None":
+            if operation.is_list_operation:
+                # List response - validate each item (paginated)
+                primary_schema = primary_response.schema_name
+                body_lines.append(f"data = response.json()")
+                body_lines.append(f'return [{primary_schema}.model_validate(item) for item in data.get("results", [])]')
+            else:
+                # Single object response
+                body_lines.append(f"return {return_type}.model_validate(response.json())")
+
+        # Render template
+        template = self.jinja_env.get_template('client/sync_operation_method.py.jinja')
+        return template.render(
+            method_name=method_name,
+            params=params,
+            return_type=return_type,
+            body_lines=body_lines,
+            docstring=docstring
+        )
+
+    def _map_param_type(self, schema_type: str) -> str:
+        """Map parameter schema type to Python type."""
+        type_map = {
+            "string": "str",
+            "integer": "int",
+            "number": "float",
+            "boolean": "bool",
+            "array": "list",
+            "object": "dict",
+        }
+        return type_map.get(schema_type, "str")

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

@@ -0,0 +1,102 @@
+"""
+Sync Client Generator - Generates sync Python clients.
+
+Handles:
+- Main SyncAPIClient class (httpx.Client)
+- Sync sub-client classes (per tag/app)
+- Mirrors async client structure without async/await
+"""
+
+from __future__ import annotations
+
+from jinja2 import Environment
+
+from ..base import GeneratedFile
+from ...ir import IROperationObject
+
+
+class SyncClientGenerator:
+    """Generates sync Python client files."""
+
+    def __init__(self, jinja_env: Environment, base_generator, operations_gen):
+        """
+        Initialize sync client generator.
+
+        Args:
+            jinja_env: Jinja2 environment for templates
+            base_generator: Reference to base generator
+            operations_gen: Operations generator instance
+        """
+        self.jinja_env = jinja_env
+        self.base = base_generator
+        self.operations_gen = operations_gen
+
+    def generate_app_sync_client_file(self, tag: str, operations: list[IROperationObject]) -> GeneratedFile:
+        """Generate sync_client.py for a specific app."""
+        class_name = self.base.tag_to_class_name(tag)
+
+        # Generate sync methods
+        method_codes = []
+        for operation in operations:
+            method_codes.append(self.operations_gen.generate_sync_operation(operation, remove_tag_prefix=True))
+
+        template = self.jinja_env.get_template('client/sync_sub_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}/sync_client.py",
+            content=content,
+            description=f"Sync API client for {tag}",
+        )
+
+    def generate_sync_main_client_file(self, ops_by_tag: dict) -> GeneratedFile:
+        """Generate sync_client.py with SyncAPIClient."""
+        tags = sorted(ops_by_tag.keys())
+
+        # Prepare tags data for template (with Sync prefix for imports)
+        tags_data = [
+            {
+                "class_name": f"Sync{self.base.tag_to_class_name(tag)}",  # Add Sync prefix
+                "slug": f"{self.base.tag_and_app_to_folder_name(tag, ops_by_tag[tag])}.sync_client",  # Import from sync_client module
+            }
+            for tag in tags
+        ]
+
+        # Generate sync APIClient class
+        sync_client_code = self._generate_sync_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=sync_client_code
+        )
+
+        return GeneratedFile(
+            path="sync_client.py",
+            content=content,
+            description="Main sync API client",
+        )
+
+    def _generate_sync_main_client_class(self, ops_by_tag: dict) -> str:
+        """Generate main SyncAPIClient with sync 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/sync_main_client.py.jinja')
+        return template.render(
+            api_title=self.base.context.openapi_info.title,
+            tags=tags_data
+        )

django_cfg/modules/django_client/core/generator/{templates/python → python/templates}/api_wrapper.py.jinja

@@ -6,24 +6,42 @@ class API:
     - Thread-safe JWT token storage
     - Automatic Authorization header injection
     - Context manager support for async operations
+    - Optional retry and logging configuration
 
     Example:
         >>> api = API('https://api.example.com')
         >>> api.set_token('jwt-token')
         >>> async with api:
         ...     users = await api.users.list()
+        >>>
+        >>> # With retry and logging
+        >>> api = API(
+        ...     'https://api.example.com',
+        ...     retry_config=RetryConfig(max_attempts=5),
+        ...     logger_config=LoggerConfig(enabled=True)
+        ... )
     """
 
-    def __init__(self, base_url: str, **kwargs: Any):
+    def __init__(
+        self,
+        base_url: str,
+        logger_config: LoggerConfig | None = None,
+        retry_config: RetryConfig | None = None,
+        **kwargs: Any
+    ):
         """
         Initialize API client.
 
         Args:
             base_url: Base API URL (e.g., 'https://api.example.com')
+            logger_config: Logger configuration (None to disable logging)
+            retry_config: Retry configuration (None to disable retry)
             **kwargs: Additional httpx.AsyncClient kwargs
         """
         self.base_url = base_url.rstrip('/')
         self._kwargs = kwargs
+        self._logger_config = logger_config
+        self._retry_config = retry_config
         self._token: str | None = None
         self._refresh_token: str | None = None
         self._lock = threading.Lock()
@@ -42,7 +60,12 @@ class API:
             kwargs['headers'] = headers
 
         # Create new APIClient
-        self._client = APIClient(self.base_url, **kwargs)
+        self._client = APIClient(
+            self.base_url,
+            logger_config=self._logger_config,
+            retry_config=self._retry_config,
+            **kwargs
+        )
 
 {% for prop in properties %}
     @property

django_cfg/modules/django_client/core/generator/{templates/python → python/templates}/client/main_client.py.jinja

@@ -6,12 +6,18 @@ class APIClient:
         >>> async with APIClient(base_url='https://api.example.com') as client:
         ...     users = await client.users.list()
         ...     post = await client.posts.create(data=new_post)
+        >>>
+        >>> # With retry configuration
+        >>> retry_config = RetryConfig(max_attempts=5, min_wait=2.0)
+        >>> async with APIClient(base_url='https://api.example.com', retry_config=retry_config) as client:
+        ...     users = await client.users.list()
     """
 
     def __init__(
         self,
         base_url: str,
         logger_config: Optional[LoggerConfig] = None,
+        retry_config: Optional[RetryConfig] = None,
         **kwargs: Any,
     ):
         """
@@ -20,14 +26,25 @@ class APIClient:
         Args:
             base_url: Base API URL (e.g., 'https://api.example.com')
             logger_config: Logger configuration (None to disable logging)
+            retry_config: Retry configuration (None to disable retry)
             **kwargs: Additional httpx.AsyncClient kwargs
         """
         self.base_url = base_url.rstrip('/')
-        self._client = httpx.AsyncClient(
-            base_url=self.base_url,
-            timeout=30.0,
-            **kwargs,
-        )
+
+        # Create HTTP client with or without retry
+        if retry_config is not None:
+            self._client = RetryAsyncClient(
+                base_url=self.base_url,
+                retry_config=retry_config,
+                timeout=30.0,
+                **kwargs,
+            )
+        else:
+            self._client = httpx.AsyncClient(
+                base_url=self.base_url,
+                timeout=30.0,
+                **kwargs,
+            )
 
         # Initialize logger
         self.logger: Optional[APILogger] = None
@@ -40,10 +57,11 @@ class APIClient:
 {% endfor %}
 
     async def __aenter__(self) -> 'APIClient':
+        await self._client.__aenter__()
         return self
 
     async def __aexit__(self, *args: Any) -> None:
-        await self._client.aclose()
+        await self._client.__aexit__(*args)
 
     async def close(self) -> None:
         """Close HTTP client."""

django_cfg/modules/django_client/core/generator/{templates/python → python/templates}/client/main_client_file.py.jinja

@@ -8,6 +8,7 @@ import httpx
 from .{{ tag.slug }} import {{ tag.class_name }}
 {% endfor %}
 from .logger import APILogger, LoggerConfig
+from .retry import RetryConfig, RetryAsyncClient
 
 
 {{ client_code }}

django_cfg/modules/django_client/core/generator/{templates/python → python/templates}/client/operation_method.py.jinja

@@ -1,6 +1,8 @@
 async def {{ method_name }}({{ params | join(', ') }}) -> {{ return_type }}:
 {% if docstring %}
-    """{{ docstring }}"""
+    """
+{{ docstring | indent(4, first=True) }}
+    """
 {% endif %}
 {% for line in body_lines %}
     {{ line }}

django_cfg/modules/django_client/core/generator/{templates/python → python/templates}/client/sub_client.py.jinja

@@ -1,3 +1,10 @@
+from __future__ import annotations
+
+import httpx
+
+from .models import *
+
+
 class {{ class_name }}:
     """API endpoints for {{ tag }}."""
 
@@ -6,6 +13,6 @@ class {{ class_name }}:
         self._client = client
 
 {% for operation in operations %}
-    {{ operation }}
+{{ operation | indent(4, first=True) }}
 
 {% endfor %}

django_cfg/modules/django_client/core/generator/python/templates/client/sync_main_client.py.jinja

@@ -0,0 +1,50 @@
+class SyncAPIClient:
+    """
+    Synchronous API client for {{ api_title }}.
+
+    Usage:
+        >>> with SyncAPIClient(base_url='https://api.example.com') as client:
+        ...     users = client.users.list()
+        ...     post = client.posts.create(data=new_post)
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        logger_config: Optional[LoggerConfig] = None,
+        **kwargs: Any,
+    ):
+        """
+        Initialize sync API client.
+
+        Args:
+            base_url: Base API URL (e.g., 'https://api.example.com')
+            logger_config: Logger configuration (None to disable logging)
+            **kwargs: Additional httpx.Client kwargs
+        """
+        self.base_url = base_url.rstrip('/')
+        self._client = httpx.Client(
+            base_url=self.base_url,
+            timeout=30.0,
+            **kwargs,
+        )
+
+        # Initialize logger
+        self.logger: Optional[APILogger] = None
+        if logger_config is not None:
+            self.logger = APILogger(logger_config)
+
+        # Initialize sub-clients
+{% for tag in tags %}
+        self.{{ tag.property }} = Sync{{ tag.class_name }}(self._client)
+{% endfor %}
+
+    def __enter__(self) -> 'SyncAPIClient':
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self._client.close()
+
+    def close(self) -> None:
+        """Close HTTP client."""
+        self._client.close()

django_cfg/modules/django_client/core/generator/python/templates/client/sync_operation_method.py.jinja

@@ -0,0 +1,9 @@
+def {{ method_name }}({{ params | join(', ') }}) -> {{ return_type }}:
+{% if docstring %}
+    """
+{{ docstring | indent(4, first=True) }}
+    """
+{% endif %}
+{% for line in body_lines %}
+    {{ line }}
+{% endfor %}

django_cfg/modules/django_client/core/generator/python/templates/client/sync_sub_client.py.jinja

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+import httpx
+
+from .models import *
+
+
+class Sync{{ class_name }}:
+    """Synchronous API endpoints for {{ tag }}."""
+
+    def __init__(self, client: httpx.Client):
+        """Initialize sync sub-client with shared httpx client."""
+        self._client = client
+
+{% for operation in operations %}
+{{ operation | indent(4, first=True) }}
+
+{% endfor %}

django_cfg/modules/django_client/core/generator/{templates/python → python/templates}/main_init.py.jinja

@@ -31,6 +31,8 @@ import httpx
 
 from .client import APIClient
 from .schema import OPENAPI_SCHEMA
+from .logger import LoggerConfig
+from .retry import RetryConfig
 {% for tag in tags %}
 from .{{ tag.slug }} import {{ tag.class_name }}
 {% endfor %}

django_cfg/modules/django_client/core/generator/{templates/python → python/templates}/models/enum_class.py.jinja

@@ -1,6 +1,8 @@
 class {{ name }}({{ base_class }}):
 {% if docstring %}
-    """{{ docstring }}"""
+    """
+{{ docstring | indent(4, first=True) }}
+    """
 {% endif %}
 {% if members %}
 {% if docstring %}

django_cfg/modules/django_client/core/generator/{templates/python → python/templates}/models/schema_class.py.jinja

@@ -1,6 +1,8 @@
 class {{ name }}(BaseModel):
 {% if docstring %}
-    """{{ docstring }}"""
+    """
+{{ docstring | indent(4, first=True) }}
+    """
 {% endif %}
 
     model_config = ConfigDict(