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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pydantic-openapi-generator
-Version: 2.3.0
+Version: 2.5.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.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pydantic-openapi-generator"
-version = "2.3.0"
+version = "2.5.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.5.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.5.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.5.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.5.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.5.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.5.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.5.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.5.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.5.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.5.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.5.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.5.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}")