pydantic-openapi-generator 2.3.0__tar.gz → 2.4.0__tar.gz

{pydantic_openapi_generator-2.3.0 → pydantic_openapi_generator-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pydantic-openapi-generator
-Version: 2.3.0
+Version: 2.4.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
@@ -20,6 +20,7 @@ Requires-Dist: isort>=5.10.1
 Requires-Dist: jinja2<4,>=3.1.2
 Requires-Dist: openapi-pydantic<0.6,>=0.5.1
 Requires-Dist: orjson<4,>=3.9.15
+Requires-Dist: pydantic-di>=0.3.1
 Requires-Dist: pydantic<3,>=2.10.2
 Requires-Dist: pyyaml<7,>=6.0.2
 Description-Content-Type: text/markdown

{pydantic_openapi_generator-2.3.0 → pydantic_openapi_generator-2.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pydantic-openapi-generator"
-version = "2.3.0"
+version = "2.4.0"
 description = "Openapi Python Generator"
 authors = [
     { name = "Marco Müllner", email = "muellnermarco@gmail.com" },
@@ -27,6 +27,7 @@ dependencies = [
     "openapi-pydantic>=0.5.1,<0.6",
     "pyyaml>=6.0.2,<7",
     "importlib-metadata>=8.7.0,<9",
+    "pydantic-di>=0.3.1",
 ]
 
 [project.urls]

{pydantic_openapi_generator-2.3.0 → pydantic_openapi_generator-2.4.0}/src/pydantic_openapi_generator/__main__.py

@@ -52,6 +52,12 @@ from pydantic_openapi_generator.generate_data import generate_data
     show_default=True,
     help="Option to choose which auto formatter is applied.",
 )
+@click.option(
+    "--config-path",
+    type=click.Path(exists=True, dir_okay=False),
+    default=None,
+    help="Optional YAML configuration for generated client parameters.",
+)
 @click.version_option(version=__version__)
 def main(
     source: str,
@@ -62,6 +68,7 @@ def main(
     custom_template_path: Optional[str] = None,
     pydantic_version: PydanticVersion = PydanticVersion.V2,
     formatter: Formatter = Formatter.BLACK,
+    config_path: Optional[str] = None,
 ) -> None:
     """
     Generate Python code from an OpenAPI 3.0+ specification.
@@ -78,6 +85,7 @@ def main(
         custom_template_path,
         pydantic_version,
         formatter,
+        config_path,
     )
 
 

pydantic_openapi_generator-2.4.0/src/pydantic_openapi_generator/config/__init__.py

@@ -0,0 +1,5 @@
+from pydantic_openapi_generator.config.parameter_source import ParameterSource
+
+__all__ = [
+    "ParameterSource",
+]

pydantic_openapi_generator-2.4.0/src/pydantic_openapi_generator/config/base_parameter.py

@@ -0,0 +1,73 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict
+
+from pydantic_openapi_generator.config.utils import Parameter, parameter_base_type_hint
+from pydantic_openapi_generator.language_converters.python import common
+from pydantic_openapi_generator.models import GeneratedParameter
+
+
+class BaseArgumentConfiguration(BaseModel, ABC):
+    model_config = ConfigDict(extra="forbid")
+
+    name: str
+    code_name: Optional[str] = None
+
+    def resolve_parameter(self, param: Parameter) -> GeneratedParameter:
+        code_name = self.resolved_code_name(param)
+        type_hint, default = self.method_type_and_default(param)
+
+        return GeneratedParameter(
+            wire_name=param.name,
+            code_name=code_name,
+            location=param.param_in,  # type: ignore[arg-type]
+            type_hint=type_hint,
+            base_type_hint=parameter_base_type_hint(param),
+            required=param.required,
+            default=default,
+            source=self.type,  # type: ignore[attr-defined]
+            is_secret=self.is_secret_parameter(),
+            field_type_hint=self.field_type_hint(param),
+            field_default=self.field_default(param),
+            getter_name=self.getter_name(code_name),
+            local_name=self.local_name(code_name),
+            value_expression=self.value_expression(code_name),
+        )
+
+    def resolved_code_name(self, param: Parameter) -> str:
+        if self.code_name:
+            return common.normalize_symbol(self.code_name)
+        return self.default_code_name(param.name)
+
+    @abstractmethod
+    def default_code_name(self, param_name: str) -> str:
+        raise NotImplementedError
+
+    @abstractmethod
+    def method_type_and_default(self, param: Parameter) -> tuple[str, Optional[str]]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def field_type_hint(self, param: Parameter) -> Optional[str]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def field_default(self, param: Parameter) -> Optional[str]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def getter_name(self, code_name: str) -> Optional[str]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def local_name(self, code_name: str) -> Optional[str]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def value_expression(self, code_name: str) -> str:
+        raise NotImplementedError
+
+    @abstractmethod
+    def is_secret_parameter(self) -> bool:
+        raise NotImplementedError

pydantic_openapi_generator-2.4.0/src/pydantic_openapi_generator/config/class_var_parameter.py

@@ -0,0 +1,60 @@
+from typing import Literal, Optional, override
+
+from pydantic_openapi_generator.config.base_parameter import (
+    BaseArgumentConfiguration,
+)
+from pydantic_openapi_generator.config.parameter_source import ParameterSource
+from pydantic_openapi_generator.config.utils import (
+    Parameter,
+    lower_code_name,
+    optional_override_type_and_default,
+    optional_type,
+    parameter_base_type_hint,
+    parameter_default,
+)
+
+
+class ClassVarArgumentConfiguration(BaseArgumentConfiguration):
+    type: Literal[ParameterSource.CLASS_VAR] = ParameterSource.CLASS_VAR
+    is_secret: bool = False
+
+    @override
+    def default_code_name(self, param_name: str) -> str:
+        return lower_code_name(param_name)
+
+    @override
+    def method_type_and_default(self, param: Parameter) -> tuple[str, Optional[str]]:
+        return optional_override_type_and_default(param)
+
+    @override
+    def field_type_hint(self, param: Parameter) -> str:
+        default = parameter_default(param)
+        base_type = "SecretStr" if self.is_secret else parameter_base_type_hint(param)
+
+        if param.required or default is not None:
+            return base_type
+
+        return optional_type(base_type)
+
+    @override
+    def field_default(self, param: Parameter) -> Optional[str]:
+        default = parameter_default(param)
+        if param.required:
+            return None
+        return default if default is not None else "None"
+
+    @override
+    def getter_name(self, code_name: str) -> Optional[str]:
+        return None
+
+    @override
+    def local_name(self, code_name: str) -> str:
+        return f"_{code_name}"
+
+    @override
+    def value_expression(self, code_name: str) -> str:
+        return self.local_name(code_name)
+
+    @override
+    def is_secret_parameter(self) -> bool:
+        return self.is_secret

pydantic_openapi_generator-2.4.0/src/pydantic_openapi_generator/config/function_parameter.py

@@ -0,0 +1,47 @@
+from typing import Literal, Optional, override
+
+from pydantic_openapi_generator.config.base_parameter import (
+    BaseArgumentConfiguration,
+)
+from pydantic_openapi_generator.config.parameter_source import ParameterSource
+from pydantic_openapi_generator.config.utils import (
+    Parameter,
+    lower_code_name,
+    optional_override_type_and_default,
+)
+
+
+class FunctionArgumentConfiguration(BaseArgumentConfiguration):
+    type: Literal[ParameterSource.FUNCTION] = ParameterSource.FUNCTION
+
+    @override
+    def default_code_name(self, param_name: str) -> str:
+        return lower_code_name(param_name)
+
+    @override
+    def method_type_and_default(self, param: Parameter) -> tuple[str, Optional[str]]:
+        return optional_override_type_and_default(param)
+
+    @override
+    def field_type_hint(self, param: Parameter) -> Optional[str]:
+        return None
+
+    @override
+    def field_default(self, param: Parameter) -> Optional[str]:
+        return None
+
+    @override
+    def getter_name(self, code_name: str) -> str:
+        return f"get_{code_name}"
+
+    @override
+    def local_name(self, code_name: str) -> str:
+        return f"_{code_name}"
+
+    @override
+    def value_expression(self, code_name: str) -> str:
+        return self.local_name(code_name)
+
+    @override
+    def is_secret_parameter(self) -> bool:
+        return False

pydantic_openapi_generator-2.4.0/src/pydantic_openapi_generator/config/generator_config.py

@@ -0,0 +1,33 @@
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+from pydantic_openapi_generator.config.base_parameter import BaseArgumentConfiguration
+from pydantic_openapi_generator.config.kwarg_parameter import KwargArgumentConfiguration
+from pydantic_openapi_generator.config.parameter_union import ArgumentConfiguration
+
+
+class PydanticOpenAPIGeneratorConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    parameters: list[ArgumentConfiguration] = Field(default_factory=list)
+
+    def parameter_configuration_for(self, parameter_name: str) -> BaseArgumentConfiguration:
+        configured = self.parameters_by_name().get(parameter_name)
+        return configured if configured is not None else KwargArgumentConfiguration(name=parameter_name)
+
+    def parameters_by_name(self) -> dict[str, ArgumentConfiguration]:
+        return {parameter.name: parameter for parameter in self.parameters}
+
+    @model_validator(mode="after")
+    def validate_unique_parameter_names(self) -> "PydanticOpenAPIGeneratorConfig":
+        names: set[str] = set()
+        duplicates: set[str] = set()
+        for parameter in self.parameters:
+            if parameter.name in names:
+                duplicates.add(parameter.name)
+            names.add(parameter.name)
+
+        if duplicates:
+            duplicate_list = ", ".join(sorted(duplicates))
+            raise ValueError(f"Duplicate parameter configuration for: {duplicate_list}")
+
+        return self

pydantic_openapi_generator-2.4.0/src/pydantic_openapi_generator/config/kwarg_parameter.py

@@ -0,0 +1,56 @@
+from typing import Literal, Optional, override
+
+from pydantic_openapi_generator.config.base_parameter import BaseArgumentConfiguration
+from pydantic_openapi_generator.config.parameter_source import ParameterSource
+from pydantic_openapi_generator.config.utils import (
+    Parameter,
+    optional_type,
+    parameter_base_type_hint,
+    parameter_default,
+)
+from pydantic_openapi_generator.language_converters.python import common
+
+
+class KwargArgumentConfiguration(BaseArgumentConfiguration):
+    type: Literal[ParameterSource.KWARG] = ParameterSource.KWARG
+
+    @override
+    def default_code_name(self, param_name: str) -> str:
+        return common.normalize_symbol(param_name)
+
+    @override
+    def method_type_and_default(self, param: Parameter) -> tuple[str, Optional[str]]:
+        base_type = parameter_base_type_hint(param)
+        default = parameter_default(param)
+
+        if param.required:
+            return base_type, None
+
+        if default is not None:
+            return base_type, default
+
+        return optional_type(base_type), "None"
+
+    @override
+    def field_type_hint(self, param: Parameter) -> Optional[str]:
+        return None
+
+    @override
+    def field_default(self, param: Parameter) -> Optional[str]:
+        return None
+
+    @override
+    def getter_name(self, code_name: str) -> Optional[str]:
+        return None
+
+    @override
+    def local_name(self, code_name: str) -> Optional[str]:
+        return None
+
+    @override
+    def value_expression(self, code_name: str) -> str:
+        return code_name
+
+    @override
+    def is_secret_parameter(self) -> bool:
+        return False

pydantic_openapi_generator-2.4.0/src/pydantic_openapi_generator/config/loader.py

@@ -0,0 +1,17 @@
+from pathlib import Path
+from typing import Optional
+
+from pydantic_di.loaders import ObjectLoaderYaml
+
+from pydantic_openapi_generator.config.generator_config import (
+    PydanticOpenAPIGeneratorConfig,
+)
+
+
+def load_config(config_path: Optional[str | Path]) -> PydanticOpenAPIGeneratorConfig:
+    if config_path is None:
+        return PydanticOpenAPIGeneratorConfig()
+
+    return ObjectLoaderYaml[PydanticOpenAPIGeneratorConfig](
+        path=Path(config_path),
+    ).load()

pydantic_openapi_generator-2.4.0/src/pydantic_openapi_generator/config/parameter_source.py

@@ -0,0 +1,7 @@
+from enum import StrEnum
+
+
+class ParameterSource(StrEnum):
+    KWARG = "Kwarg"
+    CLASS_VAR = "ClassVar"
+    FUNCTION = "Function"

pydantic_openapi_generator-2.4.0/src/pydantic_openapi_generator/config/parameter_union.py

@@ -0,0 +1,16 @@
+from typing import Annotated
+
+from pydantic import Field
+
+from pydantic_openapi_generator.config.class_var_parameter import (
+    ClassVarArgumentConfiguration,
+)
+from pydantic_openapi_generator.config.function_parameter import (
+    FunctionArgumentConfiguration,
+)
+from pydantic_openapi_generator.config.kwarg_parameter import KwargArgumentConfiguration
+
+ArgumentConfiguration = Annotated[
+    KwargArgumentConfiguration | ClassVarArgumentConfiguration | FunctionArgumentConfiguration,
+    Field(discriminator="type"),
+]

pydantic_openapi_generator-2.4.0/src/pydantic_openapi_generator/config/utils.py

@@ -0,0 +1,56 @@
+import re
+from typing import Any, 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_0.parameter import Parameter as Parameter30
+from openapi_pydantic.v3.v3_1 import Reference as Reference31
+from openapi_pydantic.v3.v3_1 import Schema as Schema31
+from openapi_pydantic.v3.v3_1.parameter import Parameter as Parameter31
+
+from pydantic_openapi_generator.language_converters.python import common
+from pydantic_openapi_generator.language_converters.python.model_generator import (
+    type_converter,
+)
+
+Parameter = Union[Parameter30, Parameter31]
+
+
+def lower_code_name(value: str) -> str:
+    normalized = common.normalize_symbol(value)
+    parts = re.findall(r"[A-Z]+(?=[A-Z][a-z0-9]|$)|[A-Z]?[a-z0-9]+", normalized)
+    return "_".join(part.lower() for part in parts) or normalized.lower()
+
+
+def literal_default(schema: Any) -> Optional[str]:
+    default = getattr(schema, "default", None)
+    return f"{default!r}" if default is not None else None
+
+
+def optional_type(type_hint: str) -> str:
+    if type_hint.startswith("Optional[") and type_hint.endswith("]"):
+        return type_hint
+    return f"Optional[{type_hint}]"
+
+
+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}]"
+    return "Any"
+
+
+def parameter_base_type_hint(param: Parameter) -> str:
+    return parameter_type_hint(param, True)
+
+
+def parameter_default(param: Parameter) -> Optional[str]:
+    if isinstance(param.param_schema, (Schema30, Schema31)):
+        return literal_default(param.param_schema)
+    return None
+
+
+def optional_override_type_and_default(param: Parameter) -> tuple[str, Optional[str]]:
+    return optional_type(parameter_base_type_hint(param)), "None"

{pydantic_openapi_generator-2.3.0 → pydantic_openapi_generator-2.4.0}/src/pydantic_openapi_generator/generate_data.py

@@ -12,6 +12,8 @@ from httpx import ConnectError, ConnectTimeout
 from pydantic import ValidationError
 
 from .common import FormatOptions, Formatter, HTTPLibrary, PydanticVersion
+from .config.generator_config import PydanticOpenAPIGeneratorConfig
+from .config.loader import load_config
 from .models import ConversionResult
 from .parsers import (
     generate_code_3_0,
@@ -203,11 +205,14 @@ def generate_data(
     custom_template_path: Optional[str] = None,
     pydantic_version: PydanticVersion = PydanticVersion.V2,
     formatter: Formatter = Formatter.BLACK,
+    config_path: Optional[Union[str, Path]] = None,
+    config: Optional[PydanticOpenAPIGeneratorConfig] = None,
 ) -> None:
     """
     Generate Python code from an OpenAPI 3.0+ specification.
     """
     openapi_obj, version = get_open_api(source)
+    loaded_config = config if config is not None else load_config(config_path)
     click.echo(f"Generating data from {source} (OpenAPI {version})")
 
     # Use version-specific generator
@@ -219,6 +224,7 @@ def generate_data(
             use_orjson,
             custom_template_path,
             pydantic_version,
+            loaded_config,
         )
     elif version == "3.1":
         result = generate_code_3_1(
@@ -228,6 +234,7 @@ def generate_data(
             use_orjson,
             custom_template_path,
             pydantic_version,
+            loaded_config,
         )
     else:
         raise ValueError(f"Unsupported OpenAPI version: {version}")

{pydantic_openapi_generator-2.3.0 → pydantic_openapi_generator-2.4.0}/src/pydantic_openapi_generator/language_converters/python/client_generator.py

@@ -39,6 +39,10 @@ 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.generator_config import (
+    PydanticOpenAPIGeneratorConfig,
+)
+from pydantic_openapi_generator.config.parameter_source import ParameterSource
 from pydantic_openapi_generator.language_converters.python import common
 from pydantic_openapi_generator.language_converters.python.jinja_config import (
     ASYNC_CLIENT_HTTPX_TEMPLATE_PYDANTIC_V2,
@@ -49,6 +53,7 @@ from pydantic_openapi_generator.language_converters.python.model_generator impor
     type_converter,
 )
 from pydantic_openapi_generator.models import (
+    GeneratedParameter,
     LibraryConfig,
     Model,
     OpReturnType,
@@ -58,6 +63,15 @@ from pydantic_openapi_generator.models import (
     TypeConversion,
 )
 
+RESERVED_CLIENT_MEMBER_NAMES = {
+    "base_url",
+    "verify",
+    "access_token",
+    "get_access_token",
+    "set_access_token",
+    "model_config",
+}
+
 
 # Helper functions for isinstance checks across OpenAPI versions
 def is_response_type(obj) -> bool:
@@ -222,6 +236,112 @@ def generate_body_param(operation: Operation) -> Union[str, None]:
     return None if request_body is None else request_body.expression
 
 
+def _resolve_parameter(
+    param: Union[Parameter30, Parameter31],
+    config: PydanticOpenAPIGeneratorConfig,
+) -> GeneratedParameter:
+    return config.parameter_configuration_for(param.name).resolve_parameter(param)
+
+
+def _method_signature(parameters: List[GeneratedParameter], body_param: Optional[str]) -> str:
+    required_params: List[str] = []
+    default_params: List[str] = []
+
+    for parameter in parameters:
+        rendered = f"{parameter.code_name}: {parameter.type_hint}"
+        if parameter.default is None:
+            required_params.append(rendered)
+        else:
+            default_params.append(f"{rendered} = {parameter.default}")
+
+    if body_param is not None:
+        required_params.append(body_param)
+
+    all_params = required_params + default_params
+    return ", ".join(all_params) + (", " if all_params else "")
+
+
+def _body_signature_param(operation: Operation) -> Optional[str]:
+    if operation.requestBody is None or is_reference_type(operation.requestBody):
+        if isinstance(operation.requestBody, (Reference, Reference30, Reference31)):
+            return f"data : {operation.requestBody.ref.split('/')[-1]}"  # type: ignore
+        return None
+
+    rb_content = getattr(operation.requestBody, "content", None)
+    operation_request_body_types = [
+        "application/json",
+        "text/plain",
+        "multipart/form-data",
+        "application/x-www-form-urlencoded",
+        "application/octet-stream",
+    ]
+    if not isinstance(rb_content, dict):
+        return None
+    content_type = next((i for i in operation_request_body_types if rb_content.get(i)), None)
+    if content_type is None:
+        return None
+    content = rb_content.get(content_type)
+    if content is None or not hasattr(content, "media_type_schema"):
+        return None
+    mts = getattr(content, "media_type_schema", None)
+    if isinstance(mts, (Reference, Reference30, Reference31)):
+        return f"data : {mts.ref.split('/')[-1]}"  # type: ignore
+    if isinstance(mts, (Schema, Schema30, Schema31)):
+        return f"data : {type_converter(mts, True).converted_type}"  # type: ignore
+    return None
+
+
+def _parameter_dict_items(parameters: List[GeneratedParameter]) -> List[str]:
+    return [f"{p.wire_name!r}: {p.value_expression}" for p in parameters]
+
+
+def _resolved_path_name(path_name: str, path_params: List[GeneratedParameter]) -> str:
+    resolved = path_name
+    for parameter in path_params:
+        resolved = re.sub(
+            r"\{" + re.escape(parameter.wire_name) + r"\}",
+            "{" + (parameter.value_expression or parameter.code_name) + "}",
+            resolved,
+        )
+    return clean_up_path_name(resolved)
+
+
+def _collect_client_parameters(
+    operations: List[ServiceOperation],
+    source: ParameterSource,
+) -> List[GeneratedParameter]:
+    collected: Dict[str, GeneratedParameter] = {}
+    wire_by_code_name: Dict[str, str] = {}
+
+    for operation in operations:
+        for parameter in operation.path_params + operation.query_params + operation.header_params:
+            if parameter.source != source:
+                continue
+
+            if parameter.code_name in RESERVED_CLIENT_MEMBER_NAMES:
+                raise ValueError(f"Configured parameter code_name {parameter.code_name!r} is reserved")
+
+            existing_wire_name = wire_by_code_name.get(parameter.code_name)
+            if existing_wire_name is not None and existing_wire_name != parameter.wire_name:
+                raise ValueError(
+                    f"Configured parameter code_name {parameter.code_name!r} is used by both "
+                    f"{existing_wire_name!r} and {parameter.wire_name!r}"
+                )
+
+            wire_by_code_name[parameter.code_name] = parameter.wire_name
+            existing = collected.get(parameter.code_name)
+            if existing is None:
+                collected[parameter.code_name] = parameter
+                continue
+
+            if not existing.required and parameter.required:
+                existing.required = True
+                existing.field_type_hint = parameter.field_type_hint
+                existing.field_default = parameter.field_default
+
+    return list(collected.values())
+
+
 def generate_params(operation: Operation) -> str:
     def _schema_default(schema: Any) -> Any:
         default = getattr(schema, "default", None)
@@ -339,6 +459,25 @@ def generate_header_params(operation: Operation) -> List[str]:
     return _generate_params(operation, "header")
 
 
+def generate_operation_parameters(
+    operation: Operation,
+    config: PydanticOpenAPIGeneratorConfig,
+    param_in: Optional[Literal["path", "query", "header", "cookie"]] = None,
+) -> List[GeneratedParameter]:
+    if operation.parameters is None:
+        return []
+
+    parameters: List[GeneratedParameter] = []
+    for param in operation.parameters:
+        if not isinstance(param, (Parameter30, Parameter31)):
+            continue
+        if param_in is not None and param.param_in != param_in:
+            continue
+        parameters.append(_resolve_parameter(param, config))
+
+    return parameters
+
+
 def _is_binary_schema(schema: Any) -> bool:
     schema_format = getattr(schema, "schema_format", None)
     schema_type = getattr(schema, "type", None)
@@ -524,6 +663,7 @@ def generate_clients(
     library_config: LibraryConfig,
     env_token_name: Optional[str],
     pydantic_version: PydanticVersion,
+    config: Optional[PydanticOpenAPIGeneratorConfig] = None,
 ) -> List[Model]:
     """
     Generate two client modules:
@@ -533,6 +673,7 @@ def generate_clients(
     jinja_env = create_jinja_env()
 
     service_ops: List[ServiceOperation] = []
+    generator_config = config or PydanticOpenAPIGeneratorConfig()
 
     def _generate_service_operation(
         op: Operation,
@@ -556,24 +697,29 @@ def generate_clients(
                         op.parameters = []  # type: ignore
                     op.parameters.append(p)  # type: ignore
 
-        params = generate_params(op)
+        request_body = generate_request_body(op)
+        body_param = None if request_body is None else request_body.expression
+        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)
+        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.split(":")[0].strip() for p in params.split(",") if ":" in p}
+        existing_param_names = {p.code_name for p in all_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
 
         operation_id = generate_operation_id(op, http_operation, path_name)
-        query_params = generate_query_params(op)
-        header_params = generate_header_params(op)
         return_type = generate_return_type(op)
-        request_body = generate_request_body(op)
-        body_param = None if request_body is None else request_body.expression
 
         so = ServiceOperation(
             params=params,
             operation_id=operation_id,
+            path_params=path_params,
             query_params=query_params,
             header_params=header_params,
             return_type=return_type,
@@ -605,6 +751,8 @@ def generate_clients(
 
     sync_ops = [so for so in service_ops if not so.async_client]
     async_ops = [so for so in service_ops if so.async_client]
+    client_fields = _collect_client_parameters(service_ops, ParameterSource.CLASS_VAR)
+    client_functions = _collect_client_parameters(service_ops, ParameterSource.FUNCTION)
 
     openapi_dump = openapi.model_dump() if hasattr(openapi, "model_dump") else {}
 
@@ -612,11 +760,15 @@ def generate_clients(
         **openapi_dump,
         env_token_name=env_token_name,
         operations=[so.model_dump() for so in sync_ops],
+        client_fields=[p.model_dump() for p in client_fields],
+        client_functions=[p.model_dump() for p in client_functions],
     )
     async_content = jinja_env.get_template(ASYNC_CLIENT_HTTPX_TEMPLATE_PYDANTIC_V2).render(
         **openapi_dump,
         env_token_name=env_token_name,
         operations=[so.model_dump() for so in async_ops],
+        client_fields=[p.model_dump() for p in client_fields],
+        client_functions=[p.model_dump() for p in client_functions],
     )
 
     compile(sync_content, "<string>", "exec")

{pydantic_openapi_generator-2.3.0 → pydantic_openapi_generator-2.4.0}/src/pydantic_openapi_generator/language_converters/python/generator.py

@@ -4,6 +4,9 @@ from openapi_pydantic.v3.v3_0 import OpenAPI as OpenAPI30
 from openapi_pydantic.v3.v3_1 import OpenAPI as OpenAPI31
 
 from pydantic_openapi_generator.common import PydanticVersion
+from pydantic_openapi_generator.config.generator_config import (
+    PydanticOpenAPIGeneratorConfig,
+)
 from pydantic_openapi_generator.language_converters.python import common
 from pydantic_openapi_generator.language_converters.python.client_generator import (
     generate_clients,
@@ -28,6 +31,7 @@ def generator(
     use_orjson: bool = False,
     custom_template_path: Optional[str] = None,
     pydantic_version: PydanticVersion = PydanticVersion.V2,
+    config: Optional[PydanticOpenAPIGeneratorConfig] = None,
 ) -> ConversionResult:
     """
     Generate Python code from an OpenAPI 3.0+ specification.
@@ -50,7 +54,7 @@ def generator(
             models.extend(resp_alias_models)
 
     if data.paths is not None:
-        clients = generate_clients(data, data.paths, library_config, env_token_name, pydantic_version)
+        clients = generate_clients(data, data.paths, library_config, env_token_name, pydantic_version, config)
     else:
         clients = []
 

{pydantic_openapi_generator-2.3.0 → pydantic_openapi_generator-2.4.0}/src/pydantic_openapi_generator/language_converters/python/templates/async_client_httpx_pydantic_2.jinja2

@@ -7,7 +7,7 @@ from typing import Any, Dict, Optional, Union
 import json
 
 import httpx
-from pydantic import BaseModel, TypeAdapter
+from pydantic import BaseModel, SecretStr, TypeAdapter
 
 from ..models import *
 from ..exceptions import HTTPException
@@ -23,6 +23,9 @@ class AsyncClient(BaseModel):
 {% if env_token_name is none %}
     access_token: Optional[str] = None
 {% endif %}
+{% for field in client_fields %}
+    {{ 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]:
 {% if env_token_name is not none %}
@@ -44,6 +47,11 @@ class AsyncClient(BaseModel):
         self.access_token = value
 {% endif %}
 
+{% for function in client_functions %}
+    async def {{ function.getter_name }}(self) -> {{ function.base_type_hint }}:
+        raise NotImplementedError
+
+{% endfor %}
 {% for op in operations %}
     async def {{ op.operation_id }}(self{% if op.params %}, {{ op.params }}{% endif %}) -> {%- if op.is_sse -%}
 AsyncGenerator[str | dict[str, Any], None]
@@ -51,6 +59,17 @@ AsyncGenerator[str | dict[str, Any], None]
 {{ op.return_type.return_type_hint or "None" }}
 {%- endif -%}:
         base_url = self.base_url
+{% for param in op.path_params + op.query_params + op.header_params %}
+{% if param.source == "ClassVar" %}
+{% if param.is_secret %}
+        {{ param.local_name }} = {{ param.code_name }} if {{ param.code_name }} is not None else (self.{{ param.code_name }}.get_secret_value() if self.{{ param.code_name }} is not None else None)
+{% else %}
+        {{ 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 }}()
+{% endif %}
+{% endfor %}
         path = f"{{ op.path_name }}"
 
         headers = {
@@ -65,7 +84,7 @@ AsyncGenerator[str | dict[str, Any], None]
             "Accept": "{{ op.return_type.accept_content_types | join(', ') or 'application/json' }}",
 {% endif %}
 {% for hp in op.header_params %}
-            {{ hp }},
+            "{{ hp.wire_name }}": {{ hp.value_expression }},
 {% endfor %}
         }
         headers = {k: v for (k, v) in headers.items() if v is not None}
@@ -76,7 +95,7 @@ AsyncGenerator[str | dict[str, Any], None]
 
         query_params: Dict[str, Any] = {
 {% for qp in op.query_params %}
-            {{ qp }},
+            "{{ qp.wire_name }}": {{ qp.value_expression }},
 {% endfor %}
         }
         query_params = {k: v for (k, v) in query_params.items() if v is not None}

{pydantic_openapi_generator-2.3.0 → pydantic_openapi_generator-2.4.0}/src/pydantic_openapi_generator/language_converters/python/templates/sync_client_httpx_pydantic_2.jinja2

@@ -7,7 +7,7 @@ from typing import Any, Dict, Optional, Union
 import json
 
 import httpx
-from pydantic import BaseModel, TypeAdapter
+from pydantic import BaseModel, SecretStr, TypeAdapter
 
 from ..models import *
 from ..exceptions import HTTPException
@@ -23,6 +23,9 @@ class SyncClient(BaseModel):
 {% if env_token_name is none %}
     access_token: Optional[str] = None
 {% endif %}
+{% for field in client_fields %}
+    {{ 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]:
 {% if env_token_name is not none %}
@@ -44,6 +47,11 @@ class SyncClient(BaseModel):
         self.access_token = value
 {% endif %}
 
+{% for function in client_functions %}
+    def {{ function.getter_name }}(self) -> {{ function.base_type_hint }}:
+        raise NotImplementedError
+
+{% endfor %}
 {% for op in operations %}
     def {{ op.operation_id }}(self{% if op.params %}, {{ op.params }}{% endif %}) -> {%- if op.is_sse -%}
 Generator[str | dict[str, Any], None, None]
@@ -51,6 +59,17 @@ Generator[str | dict[str, Any], None, None]
 {{ op.return_type.return_type_hint or "None" }}
 {%- endif -%}:
         base_url = self.base_url
+{% for param in op.path_params + op.query_params + op.header_params %}
+{% if param.source == "ClassVar" %}
+{% if param.is_secret %}
+        {{ param.local_name }} = {{ param.code_name }} if {{ param.code_name }} is not None else (self.{{ param.code_name }}.get_secret_value() if self.{{ param.code_name }} is not None else None)
+{% else %}
+        {{ 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 }}()
+{% endif %}
+{% endfor %}
         path = f"{{ op.path_name }}"
 
         headers = {
@@ -65,7 +84,7 @@ Generator[str | dict[str, Any], None, None]
             "Accept": "{{ op.return_type.accept_content_types | join(', ') or 'application/json' }}",
 {% endif %}
 {% for hp in op.header_params %}
-            {{ hp }},
+            "{{ hp.wire_name }}": {{ hp.value_expression }},
 {% endfor %}
         }
         headers = {k: v for (k, v) in headers.items() if v is not None}
@@ -76,7 +95,7 @@ Generator[str | dict[str, Any], None, None]
 
         query_params: Dict[str, Any] = {
 {% for qp in op.query_params %}
-            {{ qp }},
+            "{{ qp.wire_name }}": {{ qp.value_expression }},
 {% endfor %}
         }
         query_params = {k: v for (k, v) in query_params.items() if v is not None}

{pydantic_openapi_generator-2.3.0 → pydantic_openapi_generator-2.4.0}/src/pydantic_openapi_generator/models.py

@@ -20,6 +20,8 @@ from openapi_pydantic.v3.v3_1 import (
 )
 from pydantic import BaseModel, Field
 
+from pydantic_openapi_generator.config.parameter_source import ParameterSource
+
 # Type unions for compatibility with both OpenAPI 3.0 and 3.1
 Operation = Union[Operation30, Operation31]
 PathItem = Union[PathItem30, PathItem31]
@@ -66,11 +68,29 @@ class RequestBodyDefinition(BaseModel):
     expression: str
 
 
+class GeneratedParameter(BaseModel):
+    wire_name: str
+    code_name: str
+    location: Literal["path", "query", "header", "cookie"]
+    type_hint: str
+    base_type_hint: str
+    required: bool
+    default: Optional[str] = None
+    source: ParameterSource = ParameterSource.KWARG
+    is_secret: bool = False
+    field_type_hint: Optional[str] = None
+    field_default: Optional[str] = None
+    getter_name: Optional[str] = None
+    local_name: Optional[str] = None
+    value_expression: Optional[str] = None
+
+
 class ServiceOperation(BaseModel):
     params: str
     operation_id: str
-    query_params: List[str]
-    header_params: List[str]
+    path_params: List[GeneratedParameter] = Field(default_factory=list)
+    query_params: List[GeneratedParameter]
+    header_params: List[GeneratedParameter]
     return_type: OpReturnType
     operation: Operation
     pathItem: PathItem

{pydantic_openapi_generator-2.3.0 → pydantic_openapi_generator-2.4.0}/src/pydantic_openapi_generator/parsers/openapi_30.py

@@ -7,6 +7,9 @@ from typing import Optional
 from openapi_pydantic.v3.v3_0 import OpenAPI
 
 from pydantic_openapi_generator.common import HTTPLibrary, PydanticVersion
+from pydantic_openapi_generator.config.generator_config import (
+    PydanticOpenAPIGeneratorConfig,
+)
 from pydantic_openapi_generator.language_converters.python.generator import (
     generator as base_generator,
 )
@@ -36,6 +39,7 @@ def generate_code_3_0(
     use_orjson: bool = False,
     custom_template_path: Optional[str] = None,
     pydantic_version: PydanticVersion = PydanticVersion.V2,
+    config: Optional[PydanticOpenAPIGeneratorConfig] = None,
 ) -> ConversionResult:
     """
     Generate Python code from OpenAPI 3.0 specification.
@@ -62,4 +66,5 @@ def generate_code_3_0(
         use_orjson=use_orjson,
         custom_template_path=custom_template_path,
         pydantic_version=pydantic_version,
+        config=config,
     )

{pydantic_openapi_generator-2.3.0 → pydantic_openapi_generator-2.4.0}/src/pydantic_openapi_generator/parsers/openapi_31.py

@@ -7,6 +7,9 @@ from typing import Optional
 from openapi_pydantic.v3.v3_1 import OpenAPI
 
 from pydantic_openapi_generator.common import HTTPLibrary, PydanticVersion
+from pydantic_openapi_generator.config.generator_config import (
+    PydanticOpenAPIGeneratorConfig,
+)
 from pydantic_openapi_generator.language_converters.python.generator import (
     generator as base_generator,
 )
@@ -36,6 +39,7 @@ def generate_code_3_1(
     use_orjson: bool = False,
     custom_template_path: Optional[str] = None,
     pydantic_version: PydanticVersion = PydanticVersion.V2,
+    config: Optional[PydanticOpenAPIGeneratorConfig] = None,
 ) -> ConversionResult:
     """
     Generate Python code from OpenAPI 3.1 specification.
@@ -62,4 +66,5 @@ def generate_code_3_1(
         use_orjson=use_orjson,
         custom_template_path=custom_template_path,
         pydantic_version=pydantic_version,
+        config=config,
     )