feat: support **kwargs with request payload to function parameters

Author: Matt Coulter

src/pydantic_openapi_generator/language_converters/python/client_generator.py

@@ -807,6 +807,7 @@ def _generate_service_operation(
         query_params = generate_operation_parameters(op, generator_config, "query")
         header_params = generate_operation_parameters(op, generator_config, "header")
         all_params = path_params + query_params + header_params
+        call_kwargs = [param.code_name for param in all_params]
         params = _method_signature(all_params, _body_signature_param(op) if body_param is not None else None)
         path_name = _resolved_path_name(path_name, path_params)
 
@@ -816,12 +817,16 @@ def _generate_service_operation(
             norm_ph = common.normalize_symbol(ph)
             if norm_ph not in existing_param_names and norm_ph:
                 params = f"{norm_ph}: Any, " + params
+                call_kwargs.insert(0, norm_ph)
+        if body_param is not None:
+            call_kwargs.append("data")
 
         operation_id = generate_operation_id(op, http_operation, path_name)
         return_type = generate_return_type(op)
 
         so = ServiceOperation(
             params=params,
+            call_kwargs=call_kwargs,
             operation_id=operation_id,
             path_params=path_params,
             query_params=query_params,

src/pydantic_openapi_generator/language_converters/python/templates/async_client_httpx_pydantic_2.jinja2

@@ -27,7 +27,7 @@ class AsyncClient(BaseModel):
     {{ field.code_name }}: {{ field.field_type_hint }}{% if field.field_default is not none %} = {{ field.field_default }}{% endif %}{{ "\n" }}
 {% endfor %}
 
-    async def get_access_token(self) -> Optional[str]:
+    async def get_access_token(self, **kwargs: Any) -> Optional[str]:
 {% if env_token_name is not none %}
         try:
             return os.environ["{{ env_token_name }}"]
@@ -48,7 +48,7 @@ class AsyncClient(BaseModel):
 {% endif %}
 
 {% for function in client_functions %}
-    async def {{ function.getter_name }}(self) -> {{ function.base_type_hint }}:
+    async def {{ function.getter_name }}(self, **kwargs: Any) -> {{ function.base_type_hint }}:
         raise NotImplementedError
 
 {% endfor %}
@@ -59,6 +59,11 @@ AsyncGenerator[str | {% if op.sse_data_handler and op.sse_data_handler.type %}{%
 {{ op.return_type.return_type_hint or "None" }}
 {%- endif -%}:
         base_url = self.base_url
+        _request_kwargs = {
+{% for kwarg in op.call_kwargs %}
+            "{{ kwarg }}": {{ kwarg }},
+{% endfor %}
+        }
 {% for param in op.path_params + op.query_params + op.header_params %}
 {% if param.source == "ClassVar" %}
 {% if param.is_secret %}
@@ -67,7 +72,7 @@ AsyncGenerator[str | {% if op.sse_data_handler and op.sse_data_handler.type %}{%
         {{ param.local_name }} = {{ param.code_name }} if {{ param.code_name }} is not None else self.{{ param.code_name }}
 {% endif %}
 {% elif param.source == "Function" %}
-        {{ param.local_name }} = {{ param.code_name }} if {{ param.code_name }} is not None else await self.{{ param.getter_name }}()
+        {{ param.local_name }} = {{ param.code_name }} if {{ param.code_name }} is not None else await self.{{ param.getter_name }}(**_request_kwargs)
 {% endif %}
 {% endfor %}
         path = f"{{ op.path_name }}"
@@ -89,7 +94,7 @@ AsyncGenerator[str | {% if op.sse_data_handler and op.sse_data_handler.type %}{%
         }
         headers = {k: v for (k, v) in headers.items() if v is not None}
 
-        _token = await self.get_access_token()
+        _token = await self.get_access_token(**_request_kwargs)
         if _token:
             headers["Authorization"] = f"Bearer {_token}"
 

src/pydantic_openapi_generator/language_converters/python/templates/sync_client_httpx_pydantic_2.jinja2

@@ -27,7 +27,7 @@ class SyncClient(BaseModel):
     {{ field.code_name }}: {{ field.field_type_hint }}{% if field.field_default is not none %} = {{ field.field_default }}{% endif %}{{ "\n" }}
 {% endfor %}
 
-    def get_access_token(self) -> Optional[str]:
+    def get_access_token(self, **kwargs: Any) -> Optional[str]:
 {% if env_token_name is not none %}
         try:
             return os.environ["{{ env_token_name }}"]
@@ -48,7 +48,7 @@ class SyncClient(BaseModel):
 {% endif %}
 
 {% for function in client_functions %}
-    def {{ function.getter_name }}(self) -> {{ function.base_type_hint }}:
+    def {{ function.getter_name }}(self, **kwargs: Any) -> {{ function.base_type_hint }}:
         raise NotImplementedError
 
 {% endfor %}
@@ -59,6 +59,11 @@ Generator[str | {% if op.sse_data_handler and op.sse_data_handler.type %}{% if o
 {{ op.return_type.return_type_hint or "None" }}
 {%- endif -%}:
         base_url = self.base_url
+        _request_kwargs = {
+{% for kwarg in op.call_kwargs %}
+            "{{ kwarg }}": {{ kwarg }},
+{% endfor %}
+        }
 {% for param in op.path_params + op.query_params + op.header_params %}
 {% if param.source == "ClassVar" %}
 {% if param.is_secret %}
@@ -67,7 +72,7 @@ Generator[str | {% if op.sse_data_handler and op.sse_data_handler.type %}{% if o
         {{ param.local_name }} = {{ param.code_name }} if {{ param.code_name }} is not None else self.{{ param.code_name }}
 {% endif %}
 {% elif param.source == "Function" %}
-        {{ param.local_name }} = {{ param.code_name }} if {{ param.code_name }} is not None else self.{{ param.getter_name }}()
+        {{ param.local_name }} = {{ param.code_name }} if {{ param.code_name }} is not None else self.{{ param.getter_name }}(**_request_kwargs)
 {% endif %}
 {% endfor %}
         path = f"{{ op.path_name }}"
@@ -89,7 +94,7 @@ Generator[str | {% if op.sse_data_handler and op.sse_data_handler.type %}{% if o
         }
         headers = {k: v for (k, v) in headers.items() if v is not None}
 
-        _token = self.get_access_token()
+        _token = self.get_access_token(**_request_kwargs)
         if _token:
             headers["Authorization"] = f"Bearer {_token}"
 

src/pydantic_openapi_generator/models.py

@@ -95,6 +95,7 @@ class GeneratedParameter(BaseModel):
 
 class ServiceOperation(BaseModel):
     params: str
+    call_kwargs: List[str] = Field(default_factory=list)
     operation_id: str
     path_params: List[GeneratedParameter] = Field(default_factory=list)
     query_params: List[GeneratedParameter]

tests/test_client_generator_contracts.py

@@ -5,6 +5,7 @@
 import sys
 import tempfile
 from pathlib import Path
+from typing import Any
 from uuid import uuid4
 
 import httpx
@@ -384,11 +385,18 @@ def thing_handler(request: httpx.Request) -> httpx.Response:
 
         class Client(client_module.AsyncClient):
             getter_calls: int = 0
+            getter_kwargs: dict[str, Any] = {}
+            token_kwargs: dict[str, Any] = {}
 
-            async def get_dynamic_header(self) -> str:
+            async def get_dynamic_header(self, **kwargs: Any) -> str:
                 self.getter_calls += 1
+                self.getter_kwargs = kwargs
                 return "from-getter"
 
+            async def get_access_token(self, **kwargs: Any) -> str | None:
+                self.token_kwargs = kwargs
+                return None
+
         client = Client(test_header="from-client", optional_header="from-class")
         asyncio.run(_run_async_configured_contract(client))
         assert client.getter_calls == 1
@@ -399,11 +407,18 @@ async def get_dynamic_header(self) -> str:
 
         class Client(client_module.SyncClient):
             getter_calls: int = 0
+            getter_kwargs: dict[str, Any] = {}
+            token_kwargs: dict[str, Any] = {}
 
-            def get_dynamic_header(self) -> str:
+            def get_dynamic_header(self, **kwargs: Any) -> str:
                 self.getter_calls += 1
+                self.getter_kwargs = kwargs
                 return "from-getter"
 
+            def get_access_token(self, **kwargs: Any) -> str | None:
+                self.token_kwargs = kwargs
+                return None
+
         client = Client(test_header="from-client", optional_header="from-class")
         client.getThing(product_brand="CGU")
         client.getThing(
@@ -414,6 +429,19 @@ def get_dynamic_header(self) -> str:
         )
         assert client.getter_calls == 1
 
+    assert client.getter_kwargs == {
+        "product_brand": "CGU",
+        "test_header": None,
+        "optional_header": None,
+        "dynamic_header": None,
+    }
+    assert client.token_kwargs == {
+        "product_brand": "AMI",
+        "test_header": "from-override",
+        "optional_header": "optional-override",
+        "dynamic_header": "function-override",
+    }
+
     first_request = requests[0]
     assert first_request.headers["X-Test-Header"] == "from-client"
     assert first_request.headers["X-Optional-Header"] == "from-class"