pydantic-openapi-generator 2.7.0__tar.gz → 2.9.0__tar.gz

{pydantic_openapi_generator-2.7.0 → pydantic_openapi_generator-2.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pydantic-openapi-generator
-Version: 2.7.0
+Version: 2.9.0
 Summary: Openapi Python Generator
 Project-URL: Homepage, https://github.com/mattcoulter7/pydantic-openapi-generator
 Project-URL: Repository, https://github.com/mattcoulter7/pydantic-openapi-generator

{pydantic_openapi_generator-2.7.0 → pydantic_openapi_generator-2.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pydantic-openapi-generator"
-version = "2.7.0"
+version = "2.9.0"
 description = "Openapi Python Generator"
 authors = [
     { name = "Marco Müllner", email = "muellnermarco@gmail.com" },

pydantic_openapi_generator-2.9.0/src/pydantic_openapi_generator/config/custom_kwarg.py

@@ -0,0 +1,63 @@
+from typing import Annotated, Literal, Optional, Union
+
+from openapi_pydantic.v3.v3_0 import Reference as Reference30
+from openapi_pydantic.v3.v3_0 import Schema as Schema30
+from openapi_pydantic.v3.v3_1 import Reference as Reference31
+from openapi_pydantic.v3.v3_1 import Schema as Schema31
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+from pydantic_openapi_generator.config.utils import literal_default, optional_type, schema_type_hint
+from pydantic_openapi_generator.language_converters.python import common
+from pydantic_openapi_generator.models import GeneratedCustomKwarg
+
+SchemaDefinition = Union[Schema30, Schema31, Reference30, Reference31]
+
+
+class CustomKwargExistsCondition(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    type: Literal["exists"]
+    ref: str
+
+
+CustomKwargCondition = Annotated[CustomKwargExistsCondition, Field(discriminator="type")]
+
+
+class CustomKwargConfiguration(BaseModel):
+    model_config = ConfigDict(extra="forbid", populate_by_name=True)
+
+    kwarg: str
+    required: bool = True
+    schema_: SchemaDefinition = Field(alias="schema")
+    condition: Optional[CustomKwargCondition] = None
+
+    @model_validator(mode="after")
+    def validate_supported_schema(self) -> "CustomKwargConfiguration":
+        if schema_type_hint(self.schema_, required=True) == "Any":
+            raise ValueError("custom_kwargs schema must define a supported OpenAPI schema")
+
+        return self
+
+    @property
+    def code_name(self) -> str:
+        return common.normalize_symbol(self.kwarg)
+
+    def resolve_custom_kwarg(self) -> GeneratedCustomKwarg:
+        default = literal_default(self.schema_)
+
+        if self.required:
+            type_hint = schema_type_hint(self.schema_, required=True)
+            rendered_default = None
+        elif default is not None:
+            type_hint = schema_type_hint(self.schema_, required=True)
+            rendered_default = default
+        else:
+            type_hint = optional_type(schema_type_hint(self.schema_, required=True))
+            rendered_default = "None"
+
+        return GeneratedCustomKwarg(
+            code_name=self.code_name,
+            type_hint=type_hint,
+            required=self.required,
+            default=rendered_default,
+        )

{pydantic_openapi_generator-2.7.0 → pydantic_openapi_generator-2.9.0}/src/pydantic_openapi_generator/config/generator_config.py

@@ -1,6 +1,7 @@
 from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 from pydantic_openapi_generator.config.base_parameter import BaseArgumentConfiguration
+from pydantic_openapi_generator.config.custom_kwarg import CustomKwargConfiguration
 from pydantic_openapi_generator.config.kwarg_parameter import KwargArgumentConfiguration
 from pydantic_openapi_generator.config.parameter_union import ArgumentConfiguration
 
@@ -9,6 +10,7 @@ class PydanticOpenAPIGeneratorConfig(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
     parameters: list[ArgumentConfiguration] = Field(default_factory=list)
+    custom_kwargs: list[CustomKwargConfiguration] = Field(default_factory=list)
 
     def parameter_configuration_for(self, parameter_name: str) -> BaseArgumentConfiguration:
         configured = self.parameters_by_name().get(parameter_name)
@@ -31,3 +33,19 @@ class PydanticOpenAPIGeneratorConfig(BaseModel):
             raise ValueError(f"Duplicate parameter configuration for: {duplicate_list}")
 
         return self
+
+    @model_validator(mode="after")
+    def validate_unique_custom_kwarg_names(self) -> "PydanticOpenAPIGeneratorConfig":
+        names: set[str] = set()
+        duplicates: set[str] = set()
+        for custom_kwarg in self.custom_kwargs:
+            code_name = custom_kwarg.code_name
+            if code_name in names:
+                duplicates.add(code_name)
+            names.add(code_name)
+
+        if duplicates:
+            duplicate_list = ", ".join(sorted(duplicates))
+            raise ValueError(f"Duplicate custom kwarg configuration for: {duplicate_list}")
+
+        return self

{pydantic_openapi_generator-2.7.0 → pydantic_openapi_generator-2.9.0}/src/pydantic_openapi_generator/config/utils.py

@@ -14,6 +14,7 @@ from pydantic_openapi_generator.language_converters.python.model_generator impor
 )
 
 Parameter = Union[Parameter30, Parameter31]
+SchemaDefinition = Union[Schema30, Schema31, Reference30, Reference31]
 
 
 def lower_code_name(value: str) -> str:
@@ -34,14 +35,20 @@ def optional_type(type_hint: str) -> str:
 
 
 def parameter_type_hint(param: Parameter, required: bool) -> str:
-    if isinstance(param.param_schema, (Schema30, Schema31)):
-        return type_converter(param.param_schema, required).converted_type
-    if isinstance(param.param_schema, (Reference30, Reference31)):
-        model_name = common.normalize_symbol(param.param_schema.ref.split("/")[-1])
-        return model_name if required else f"Optional[{model_name}]"
+    if isinstance(param.param_schema, (Schema30, Schema31, Reference30, Reference31)):
+        return schema_type_hint(param.param_schema, required=required)
     return "Any"
 
 
+def schema_type_hint(schema: SchemaDefinition, *, required: bool) -> str:
+    if isinstance(schema, (Schema30, Schema31)):
+        return type_converter(schema, required).converted_type
+    if isinstance(schema, (Reference30, Reference31)):
+        model_name = common.normalize_symbol(schema.ref.split("/")[-1])
+        return model_name if required else f"Optional[{model_name}]"
+    raise ValueError(f"Unsupported schema type: {type(schema)!r}")
+
+
 def parameter_base_type_hint(param: Parameter) -> str:
     return parameter_type_hint(param, True)
 

{pydantic_openapi_generator-2.7.0 → pydantic_openapi_generator-2.9.0}/src/pydantic_openapi_generator/language_converters/python/client_generator.py

@@ -39,6 +39,7 @@ from openapi_pydantic.v3.v3_1 import (
 from openapi_pydantic.v3.v3_1.parameter import Parameter as Parameter31
 
 from pydantic_openapi_generator.common import PydanticVersion
+from pydantic_openapi_generator.config.custom_kwarg import CustomKwargConfiguration
 from pydantic_openapi_generator.config.generator_config import (
     PydanticOpenAPIGeneratorConfig,
 )
@@ -53,6 +54,7 @@ from pydantic_openapi_generator.language_converters.python.model_generator impor
     type_converter,
 )
 from pydantic_openapi_generator.models import (
+    GeneratedCustomKwarg,
     GeneratedParameter,
     LibraryConfig,
     Model,
@@ -309,7 +311,10 @@ def _resolve_parameter(
     return config.parameter_configuration_for(param.name).resolve_parameter(param)
 
 
-def _method_signature(parameters: List[GeneratedParameter], body_param: Optional[str]) -> str:
+SignatureParameter = Union[GeneratedParameter, GeneratedCustomKwarg]
+
+
+def _method_signature(parameters: List[SignatureParameter], body_param: Optional[str]) -> str:
     required_params: List[str] = []
     default_params: List[str] = []
 
@@ -361,6 +366,42 @@ def _parameter_dict_items(parameters: List[GeneratedParameter]) -> List[str]:
     return [f"{p.wire_name!r}: {p.value_expression}" for p in parameters]
 
 
+def _custom_kwarg_applies(
+    custom_kwarg: CustomKwargConfiguration,
+    parameters: List[GeneratedParameter],
+) -> bool:
+    condition = custom_kwarg.condition
+    if condition is None:
+        return True
+
+    if condition.type == "exists":
+        ref = common.normalize_symbol(condition.ref)
+        return any(parameter.code_name == ref for parameter in parameters)
+
+    return False
+
+
+def resolve_custom_kwargs(
+    configured_custom_kwargs: List[CustomKwargConfiguration],
+    parameters: List[GeneratedParameter],
+) -> List[GeneratedCustomKwarg]:
+    custom_kwargs = [
+        custom_kwarg.resolve_custom_kwarg()
+        for custom_kwarg in configured_custom_kwargs
+        if _custom_kwarg_applies(custom_kwarg, parameters)
+    ]
+
+    parameter_code_names = {parameter.code_name for parameter in parameters}
+    collisions = sorted(
+        custom_kwarg.code_name for custom_kwarg in custom_kwargs if custom_kwarg.code_name in parameter_code_names
+    )
+    if collisions:
+        collision_list = ", ".join(collisions)
+        raise ValueError(f"Custom kwarg collides with generated API parameter code_name: {collision_list}")
+
+    return custom_kwargs
+
+
 def _resolved_path_name(path_name: str, path_params: List[GeneratedParameter]) -> str:
     resolved = path_name
     for parameter in path_params:
@@ -806,26 +847,34 @@ def generate_clients(
         path_params = generate_operation_parameters(op, generator_config, "path")
         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
-        params = _method_signature(all_params, _body_signature_param(op) if body_param is not None else None)
+        api_params = path_params + query_params + header_params
+        custom_kwargs = resolve_custom_kwargs(generator_config.custom_kwargs, api_params)
+        signature_params: List[SignatureParameter] = api_params + custom_kwargs
+        call_kwargs = [param.code_name for param in signature_params]
+        params = _method_signature(signature_params, _body_signature_param(op) if body_param is not None else None)
         path_name = _resolved_path_name(path_name, path_params)
 
         placeholder_names = [m.group(1) for m in re.finditer(r"\{([^}/]+)\}", path_name)]
-        existing_param_names = {p.code_name for p in all_params}
+        existing_param_names = {p.code_name for p in signature_params}
         for ph in placeholder_names:
             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,
             header_params=header_params,
+            custom_kwargs=custom_kwargs,
             return_type=return_type,
             operation=op,
             pathItem=path_obj,

{pydantic_openapi_generator-2.7.0 → pydantic_openapi_generator-2.9.0}/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}"
 

{pydantic_openapi_generator-2.7.0 → pydantic_openapi_generator-2.9.0}/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}"
 

{pydantic_openapi_generator-2.7.0 → pydantic_openapi_generator-2.9.0}/src/pydantic_openapi_generator/models.py

@@ -93,12 +93,21 @@ class GeneratedParameter(BaseModel):
     value_expression: Optional[str] = None
 
 
+class GeneratedCustomKwarg(BaseModel):
+    code_name: str
+    type_hint: str
+    required: bool
+    default: Optional[str] = None
+
+
 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]
     header_params: List[GeneratedParameter]
+    custom_kwargs: List[GeneratedCustomKwarg] = Field(default_factory=list)
     return_type: OpReturnType
     operation: Operation
     pathItem: PathItem