openapi-python-client 0.19.1__tar.gz → 0.21.0__tar.gz

{openapi_python_client-0.19.1 → openapi_python_client-0.21.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openapi-python-client
-Version: 0.19.1
+Version: 0.21.0
 Summary: Generate modern Python clients from OpenAPI
 Project-URL: repository, https://github.com/openapi-generators/openapi-python-client
 Author-email: Dylan Anthony <contact@dylananthony.com>
@@ -25,10 +25,10 @@ Requires-Dist: httpx<0.28.0,>=0.20.0
 Requires-Dist: jinja2<4.0.0,>=3.0.0
 Requires-Dist: pydantic<3.0.0,>=2.1.1
 Requires-Dist: python-dateutil<3.0.0,>=2.8.1
-Requires-Dist: pyyaml<7.0,>=6.0
-Requires-Dist: ruff<0.4,>=0.2
+Requires-Dist: ruamel-yaml<0.19.0,>=0.18.6
+Requires-Dist: ruff<0.5,>=0.2
 Requires-Dist: shellingham<2.0.0,>=1.3.2
-Requires-Dist: typer<0.12,>0.6
+Requires-Dist: typer<0.13,>0.6
 Requires-Dist: typing-extensions<5.0.0,>=4.8.0
 Description-Content-Type: text/markdown
 

{openapi_python_client-0.19.1 → openapi_python_client-0.21.0}/openapi_python_client/__init__.py

@@ -11,8 +11,9 @@ from typing import Any, Dict, List, Optional, Sequence, Union
 
 import httpcore
 import httpx
-import yaml
 from jinja2 import BaseLoader, ChoiceLoader, Environment, FileSystemLoader, PackageLoader
+from ruamel.yaml import YAML
+from ruamel.yaml.error import YAMLError
 
 from openapi_python_client import utils
 
@@ -64,12 +65,22 @@ class Project:
         )
 
         self.project_name: str = config.project_name_override or f"{utils.kebab_case(openapi.title).lower()}-client"
-        self.project_dir: Path = Path.cwd()
-        if config.meta_type != MetaType.NONE:
-            self.project_dir /= self.project_name
-
         self.package_name: str = config.package_name_override or self.project_name.replace("-", "_")
-        self.package_dir: Path = self.project_dir / self.package_name
+        self.project_dir: Path  # Where the generated code will be placed
+        self.package_dir: Path  # Where the generated Python module will be placed (same as project_dir if no meta)
+
+        if config.output_path is not None:
+            self.project_dir = config.output_path
+        elif config.meta_type == MetaType.NONE:
+            self.project_dir = Path.cwd() / self.package_name
+        else:
+            self.project_dir = Path.cwd() / self.project_name
+
+        if config.meta_type == MetaType.NONE:
+            self.package_dir = self.project_dir
+        else:
+            self.package_dir = self.project_dir / self.package_name
+
         self.package_description: str = utils.remove_string_escapes(
             f"A client library for accessing {self.openapi.title}"
         )
@@ -94,29 +105,16 @@ class Project:
     def build(self) -> Sequence[GeneratorError]:
         """Create the project from templates"""
 
-        if self.config.meta_type == MetaType.NONE:
-            print(f"Generating {self.package_name}")
-        else:
-            print(f"Generating {self.project_name}")
-            try:
-                self.project_dir.mkdir()
-            except FileExistsError:
-                return [GeneratorError(detail="Directory already exists. Delete it or use the update command.")]
-        self._create_package()
-        self._build_metadata()
-        self._build_models()
-        self._build_api()
-        self._run_post_hooks()
-        return self._get_errors()
-
-    def update(self) -> Sequence[GeneratorError]:
-        """Update an existing project"""
+        print(f"Generating {self.project_dir}")
+        if self.config.overwrite:
+            shutil.rmtree(self.project_dir, ignore_errors=True)
 
-        if not self.package_dir.is_dir():
-            return [GeneratorError(detail=f"Directory {self.package_dir} not found")]
-        print(f"Updating {self.package_name}")
-        shutil.rmtree(self.package_dir)
+        try:
+            self.project_dir.mkdir()
+        except FileExistsError:
+            return [GeneratorError(detail="Directory already exists. Delete it or use the --overwrite option.")]
         self._create_package()
+        self._build_metadata()
         self._build_models()
         self._build_api()
         self._run_post_hooks()
@@ -137,7 +135,7 @@ class Project:
             )
             return
         try:
-            cwd = self.package_dir if self.config.meta_type == MetaType.NONE else self.project_dir
+            cwd = self.project_dir
             subprocess.run(cmd, cwd=cwd, shell=True, capture_output=True, check=True)
         except CalledProcessError as err:
             self.errors.append(
@@ -157,7 +155,8 @@ class Project:
         return errors
 
     def _create_package(self) -> None:
-        self.package_dir.mkdir()
+        if self.package_dir != self.project_dir:
+            self.package_dir.mkdir()
         # Package __init__.py
         package_init = self.package_dir / "__init__.py"
 
@@ -302,7 +301,7 @@ def _get_project_for_url_or_path(
     )
 
 
-def create_new_client(
+def generate(
     *,
     config: Config,
     custom_template_path: Optional[Path] = None,
@@ -322,26 +321,6 @@ def create_new_client(
     return project.build()
 
 
-def update_existing_client(
-    *,
-    config: Config,
-    custom_template_path: Optional[Path] = None,
-) -> Sequence[GeneratorError]:
-    """
-    Update an existing client library
-
-    Returns:
-         A list containing any errors encountered when generating.
-    """
-    project = _get_project_for_url_or_path(
-        custom_template_path=custom_template_path,
-        config=config,
-    )
-    if isinstance(project, GeneratorError):
-        return [project]
-    return project.update()
-
-
 def _load_yaml_or_json(data: bytes, content_type: Optional[str]) -> Union[Dict[str, Any], GeneratorError]:
     if content_type == "application/json":
         try:
@@ -350,8 +329,9 @@ def _load_yaml_or_json(data: bytes, content_type: Optional[str]) -> Union[Dict[s
             return GeneratorError(header=f"Invalid JSON from provided source: {err}")
     else:
         try:
-            return yaml.safe_load(data)
-        except yaml.YAMLError as err:
+            yaml = YAML(typ="safe")
+            return yaml.load(data)
+        except YAMLError as err:
             return GeneratorError(header=f"Invalid YAML from provided source: {err}")
 
 

{openapi_python_client-0.19.1 → openapi_python_client-0.21.0}/openapi_python_client/cli.py

@@ -21,7 +21,14 @@ def _version_callback(value: bool) -> None:
 
 
 def _process_config(
-    *, url: Optional[str], path: Optional[Path], config_path: Optional[Path], meta_type: MetaType, file_encoding: str
+    *,
+    url: Optional[str],
+    path: Optional[Path],
+    config_path: Optional[Path],
+    meta_type: MetaType,
+    file_encoding: str,
+    overwrite: bool,
+    output_path: Optional[Path],
 ) -> Config:
     source: Union[Path, str]
     if url and not path:
@@ -49,7 +56,7 @@ def _process_config(
         except Exception as err:
             raise typer.BadParameter("Unable to parse config") from err
 
-    return Config.from_sources(config_file, meta_type, source, file_encoding)
+    return Config.from_sources(config_file, meta_type, source, file_encoding, overwrite, output_path=output_path)
 
 
 # noinspection PyUnusedLocal
@@ -117,62 +124,46 @@ def handle_errors(errors: Sequence[GeneratorError], fail_on_warning: bool = Fals
         raise typer.Exit(code=1)
 
 
-custom_template_path_options = {
-    "help": "A path to a directory containing custom template(s)",
-    "file_okay": False,
-    "dir_okay": True,
-    "readable": True,
-    "resolve_path": True,
-}
-
-_meta_option = typer.Option(
-    MetaType.POETRY,
-    help="The type of metadata you want to generate.",
-)
-
-CONFIG_OPTION = typer.Option(None, "--config", help="Path to the config file to use")
-
-
 @app.command()
 def generate(
-    url: Optional[str] = typer.Option(None, help="A URL to read the JSON from"),
-    path: Optional[Path] = typer.Option(None, help="A path to the JSON file"),
-    custom_template_path: Optional[Path] = typer.Option(None, **custom_template_path_options),  # type: ignore
-    meta: MetaType = _meta_option,
+    url: Optional[str] = typer.Option(None, help="A URL to read the OpenAPI document from"),
+    path: Optional[Path] = typer.Option(None, help="A path to the OpenAPI document"),
+    custom_template_path: Optional[Path] = typer.Option(
+        None,
+        help="A path to a directory containing custom template(s)",
+        file_okay=False,
+        dir_okay=True,
+        readable=True,
+        resolve_path=True,
+    ),  # type: ignore
+    meta: MetaType = typer.Option(
+        MetaType.POETRY,
+        help="The type of metadata you want to generate.",
+    ),
     file_encoding: str = typer.Option("utf-8", help="Encoding used when writing generated"),
-    config_path: Optional[Path] = CONFIG_OPTION,
+    config_path: Optional[Path] = typer.Option(None, "--config", help="Path to the config file to use"),
     fail_on_warning: bool = False,
+    overwrite: bool = typer.Option(False, help="Overwrite the existing client if it exists"),
+    output_path: Optional[Path] = typer.Option(
+        None,
+        help="Path to write the generated code to. "
+        "Defaults to the OpenAPI document title converted to kebab or snake case (depending on meta type). "
+        "Can also be overridden with `project_name_override` or `package_name_override` in config.",
+    ),
 ) -> None:
     """Generate a new OpenAPI Client library"""
-    from . import create_new_client
-
-    config = _process_config(url=url, path=path, config_path=config_path, meta_type=meta, file_encoding=file_encoding)
-    errors = create_new_client(
-        custom_template_path=custom_template_path,
-        config=config,
+    from . import generate
+
+    config = _process_config(
+        url=url,
+        path=path,
+        config_path=config_path,
+        meta_type=meta,
+        file_encoding=file_encoding,
+        overwrite=overwrite,
+        output_path=output_path,
     )
-    handle_errors(errors, fail_on_warning)
-
-
-@app.command()
-def update(
-    url: Optional[str] = typer.Option(None, help="A URL to read the JSON from"),
-    path: Optional[Path] = typer.Option(None, help="A path to the JSON file"),
-    custom_template_path: Optional[Path] = typer.Option(None, **custom_template_path_options),  # type: ignore
-    meta: MetaType = _meta_option,
-    file_encoding: str = typer.Option("utf-8", help="Encoding used when writing generated"),
-    config_path: Optional[Path] = CONFIG_OPTION,
-    fail_on_warning: bool = False,
-) -> None:
-    """Update an existing OpenAPI Client library
-
-    The update command performs the same operations as generate except it does not overwrite specific metadata for the
-    generated client such as the README.md, .gitignore, and pyproject.toml.
-    """
-    from . import update_existing_client
-
-    config = _process_config(config_path=config_path, meta_type=meta, url=url, path=path, file_encoding=file_encoding)
-    errors = update_existing_client(
+    errors = generate(
         custom_template_path=custom_template_path,
         config=config,
     )

{openapi_python_client-0.19.1 → openapi_python_client-0.21.0}/openapi_python_client/config.py

@@ -4,9 +4,9 @@ from enum import Enum
 from pathlib import Path
 from typing import Dict, List, Optional, Union
 
-import yaml
 from attr import define
 from pydantic import BaseModel
+from ruamel.yaml import YAML
 
 
 class ClassOverride(BaseModel):
@@ -51,7 +51,8 @@ class ConfigFile(BaseModel):
         if mime == "application/json":
             config_data = json.loads(path.read_text())
         else:
-            config_data = yaml.safe_load(path.read_text())
+            yaml = YAML(typ="safe")
+            config_data = yaml.load(path)
         config = ConfigFile(**config_data)
         return config
 
@@ -72,10 +73,17 @@ class Config:
     document_source: Union[Path, str]
     file_encoding: str
     content_type_overrides: Dict[str, str]
+    overwrite: bool
+    output_path: Optional[Path]
 
     @staticmethod
     def from_sources(
-        config_file: ConfigFile, meta_type: MetaType, document_source: Union[Path, str], file_encoding: str
+        config_file: ConfigFile,
+        meta_type: MetaType,
+        document_source: Union[Path, str],
+        file_encoding: str,
+        overwrite: bool,
+        output_path: Optional[Path],
     ) -> "Config":
         if config_file.post_hooks is not None:
             post_hooks = config_file.post_hooks
@@ -103,5 +111,7 @@ class Config:
             http_timeout=config_file.http_timeout,
             document_source=document_source,
             file_encoding=file_encoding,
+            overwrite=overwrite,
+            output_path=output_path,
         )
         return config

{openapi_python_client-0.19.1 → openapi_python_client-0.21.0}/openapi_python_client/parser/properties/const.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, overload
+from typing import Any, ClassVar, overload
 
 from attr import define
 
@@ -12,7 +12,7 @@ from .string import StringProperty
 
 @define
 class ConstProperty(PropertyProtocol):
-    """A property representing a Union (anyOf) of other properties"""
+    """A property representing a const value"""
 
     name: str
     required: bool
@@ -21,6 +21,7 @@ class ConstProperty(PropertyProtocol):
     python_name: PythonIdentifier
     description: str | None
     example: None
+    template: ClassVar[str] = "const_property.py.jinja"
 
     @classmethod
     def build(

{openapi_python_client-0.19.1 → openapi_python_client-0.21.0}/openapi_python_client/parser/properties/model_property.py

@@ -7,7 +7,9 @@ from attrs import define, evolve
 
 from ... import Config, utils
 from ... import schema as oai
+from ...utils import PythonIdentifier
 from ..errors import ParseError, PropertyError
+from .any import AnyProperty
 from .enum_property import EnumProperty
 from .protocol import PropertyProtocol, Value
 from .schemas import Class, ReferencePath, Schemas, parse_reference_path
@@ -30,7 +32,7 @@ class ModelProperty(PropertyProtocol):
     optional_properties: list[Property] | None
     relative_imports: set[str] | None
     lazy_imports: set[str] | None
-    additional_properties: bool | Property | None
+    additional_properties: Property | None
     _json_type_string: ClassVar[str] = "Dict[str, Any]"
 
     template: ClassVar[str] = "model_property.py.jinja"
@@ -78,7 +80,7 @@ class ModelProperty(PropertyProtocol):
         optional_properties: list[Property] | None = None
         relative_imports: set[str] | None = None
         lazy_imports: set[str] | None = None
-        additional_properties: bool | Property | None = None
+        additional_properties: Property | None = None
         if process_properties:
             data_or_err, schemas = _process_property_data(
                 data=data, schemas=schemas, class_info=class_info, config=config, roots=model_roots
@@ -386,6 +388,16 @@ def _process_properties(  # noqa: PLR0912, PLR0911
     )
 
 
+ANY_ADDITIONAL_PROPERTY = AnyProperty.build(
+    name="additional",
+    required=True,
+    default=None,
+    description="",
+    python_name=PythonIdentifier(value="additional", prefix=""),
+    example=None,
+)
+
+
 def _get_additional_properties(
     *,
     schema_additional: None | (bool | (oai.Reference | oai.Schema)),
@@ -393,18 +405,20 @@ def _get_additional_properties(
     class_name: utils.ClassName,
     config: Config,
     roots: set[ReferencePath | utils.ClassName],
-) -> tuple[bool | (Property | PropertyError), Schemas]:
+) -> tuple[Property | None | PropertyError, Schemas]:
     from . import property_from_data
 
     if schema_additional is None:
-        return True, schemas
+        return ANY_ADDITIONAL_PROPERTY, schemas
 
     if isinstance(schema_additional, bool):
-        return schema_additional, schemas
+        if schema_additional:
+            return ANY_ADDITIONAL_PROPERTY, schemas
+        return None, schemas
 
     if isinstance(schema_additional, oai.Schema) and not any(schema_additional.model_dump().values()):
         # An empty schema
-        return True, schemas
+        return ANY_ADDITIONAL_PROPERTY, schemas
 
     additional_properties, schemas = property_from_data(
         name="AdditionalProperty",
@@ -425,7 +439,7 @@ def _process_property_data(
     class_info: Class,
     config: Config,
     roots: set[ReferencePath | utils.ClassName],
-) -> tuple[tuple[_PropertyData, bool | Property] | PropertyError, Schemas]:
+) -> tuple[tuple[_PropertyData, Property | None] | PropertyError, Schemas]:
     property_data = _process_properties(
         data=data, schemas=schemas, class_name=class_info.name, config=config, roots=roots
     )
@@ -442,7 +456,7 @@ def _process_property_data(
     )
     if isinstance(additional_properties, PropertyError):
         return additional_properties, schemas
-    elif isinstance(additional_properties, bool):
+    elif additional_properties is None:
         pass
     else:
         property_data.relative_imports.update(additional_properties.get_imports(prefix=".."))

{openapi_python_client-0.19.1 → openapi_python_client-0.21.0}/openapi_python_client/parser/properties/protocol.py

@@ -107,6 +107,8 @@ class PropertyProtocol(Protocol):
         """
         if json:
             type_string = self.get_base_json_type_string(quoted=quoted)
+        elif multipart:
+            type_string = "Tuple[None, bytes, str]"
         else:
             type_string = self.get_base_type_string(quoted=quoted)
 

{openapi_python_client-0.19.1 → openapi_python_client-0.21.0}/openapi_python_client/templates/endpoint_macros.py.jinja

@@ -83,8 +83,8 @@ params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
 {% macro multipart_body(body, destination) %}
 {% set property = body.prop %}
 {% import "property_templates/" + property.template as prop_template %}
-{% if prop_template.transform_multipart %}
-{{ prop_template.transform_multipart(property, property.python_name, destination) }}
+{% if prop_template.transform_multipart_body %}
+{{ prop_template.transform_multipart_body(property, property.python_name, destination) }}
 {% endif %}
 {% endmacro %}
 

{openapi_python_client-0.19.1 → openapi_python_client-0.21.0}/openapi_python_client/templates/model.py.jinja

@@ -80,10 +80,10 @@ class {{ class_name }}:
 {% macro _to_dict(multipart=False) %}
 {% for property in model.required_properties + model.optional_properties %}
 {% import "property_templates/" + property.template as prop_template %}
-{% if prop_template.transform %}
-{{ prop_template.transform(property, "self." + property.python_name, property.python_name, multipart=multipart) }}
-{% elif multipart %}
-{{ property.python_name }} = self.{{ property.python_name }} if isinstance(self.{{ property.python_name }}, Unset) else (None, str(self.{{ property.python_name }}).encode(), "text/plain")
+{% if multipart %}
+{{ prop_template.transform_multipart(property, "self." + property.python_name, property.python_name) }}
+{% elif prop_template.transform %}
+{{ prop_template.transform(property=property, source="self." + property.python_name, destination=property.python_name) }}
 {% else %}
 {{ property.python_name }} = self.{{ property.python_name }}
 {% endif %}
@@ -92,19 +92,13 @@ class {{ class_name }}:
 
 field_dict: Dict[str, Any] = {}
 {% if model.additional_properties %}
-{% if model.additional_properties.template %}{# Can be a bool instead of an object #}
-    {% import "property_templates/" + model.additional_properties.template as prop_template %}
-{% else %}
-    {% set prop_template = None %}
-{% endif %}
-{% if prop_template and prop_template.transform %}
+{% import "property_templates/" + model.additional_properties.template as prop_template %}
+{% if multipart %}
 for prop_name, prop in self.additional_properties.items():
-    {{ prop_template.transform(model.additional_properties, "prop", "field_dict[prop_name]", multipart=multipart, declare_type=false) | indent(4) }}
-{% elif multipart %}
-field_dict.update({
-    key: (None, str(value).encode(), "text/plain")
-    for key, value in self.additional_properties.items()
-})
+    {{ prop_template.transform_multipart(model.additional_properties, "prop", "field_dict[prop_name]") | indent(4) }}
+{% elif prop_template.transform %}
+for prop_name, prop in self.additional_properties.items():
+    {{ prop_template.transform(model.additional_properties, "prop", "field_dict[prop_name]", declare_type=false) | indent(4) }}
 {% else %}
 field_dict.update(self.additional_properties)
 {% endif %}

openapi_python_client-0.21.0/openapi_python_client/templates/property_templates/any_property.py.jinja

@@ -0,0 +1,7 @@
+{% macro transform_multipart(property, source, destination) %}
+{% if not property.required %}
+{{ destination }} = {{source}} if isinstance({{source}}, Unset) else (None, str({{source}}).encode(), "text/plain")
+{% else %}
+{{ destination }} =  (None, str({{ source }}).encode(), "text/plain")
+{% endif %}
+{% endmacro %}

openapi_python_client-0.21.0/openapi_python_client/templates/property_templates/boolean_property.py.jinja

@@ -0,0 +1,11 @@
+{% macro transform_header(source) %}
+"true" if {{ source }} else "false"
+{% endmacro %}
+
+{% macro transform_multipart(property, source, destination) %}
+{% if not property.required %}
+{{ destination }} = {{source}} if isinstance({{source}}, Unset) else (None, str({{source}}).encode(), "text/plain")
+{% else %}
+{{ destination }} =  (None, str({{ source }}).encode(), "text/plain")
+{% endif %}
+{% endmacro %}

openapi_python_client-0.21.0/openapi_python_client/templates/property_templates/const_property.py.jinja

@@ -0,0 +1,5 @@
+{% macro construct(property, source) %}
+{{ property.python_name }} = cast({{ property.get_type_string() }} , {{ source }})
+if {{ property.python_name }} != {{ property.value }}{% if not property.required %}and not isinstance({{ property.python_name }}, Unset){% endif %}:
+    raise ValueError(f"{{ property.name }} must match const {{ property.value }}, got '{{'{' + property.python_name + '}' }}'")
+{%- endmacro %}

{openapi_python_client-0.19.1 → openapi_python_client-0.21.0}/openapi_python_client/templates/property_templates/date_property.py.jinja

@@ -10,17 +10,13 @@ isoparse({{ source }}).date()
 
 {% macro check_type_for_construct(property, source) %}isinstance({{ source }}, str){% endmacro %}
 
-{% macro transform(property, source, destination, declare_type=True, multipart=False) %}
+{% macro transform(property, source, destination, declare_type=True) %}
 {% set transformed = source + ".isoformat()" %}
-{% if multipart %}{# Multipart data must be bytes, not str #}
-{% set transformed = transformed + ".encode()" %}
-{% endif %}
 {% if property.required %}
 {{ destination }} = {{ transformed }}
 {%- else %}
 {% if declare_type %}
 {% set type_annotation = property.get_type_string(json=True) %}
-{% if multipart %}{% set type_annotation = type_annotation | replace("str", "bytes") %}{% endif %}
 {{ destination }}: {{ type_annotation }} = UNSET
 {% else %}
 {{ destination }} = UNSET
@@ -29,3 +25,15 @@ if not isinstance({{ source }}, Unset):
     {{ destination }} = {{ transformed }}
 {%- endif %}
 {% endmacro %}
+
+{% macro transform_multipart(property, source, destination) %}
+{% set transformed = source + ".isoformat().encode()" %}
+{% if property.required %}
+{{ destination }} = {{ transformed }}
+{%- else %}
+{% set type_annotation = property.get_type_string(json=True) | replace("str", "bytes") %}
+{{ destination }}: {{ type_annotation }} = UNSET
+if not isinstance({{ source }}, Unset):
+    {{ destination }} = {{ transformed }}
+{%- endif %}
+{% endmacro %}

{openapi_python_client-0.19.1 → openapi_python_client-0.21.0}/openapi_python_client/templates/property_templates/datetime_property.py.jinja

@@ -10,17 +10,13 @@ isoparse({{ source }})
 
 {% macro check_type_for_construct(property, source) %}isinstance({{ source }}, str){% endmacro %}
 
-{% macro transform(property, source, destination, declare_type=True, multipart=False) %}
+{% macro transform(property, source, destination, declare_type=True) %}
 {% set transformed = source + ".isoformat()" %}
-{% if multipart %}{# Multipart data must be bytes, not str #}
-{% set transformed = transformed + ".encode()" %}
-{% endif %}
 {% if property.required %}
 {{ destination }} = {{ transformed }}
 {%- else %}
 {% if declare_type %}
 {% set type_annotation = property.get_type_string(json=True) %}
-{% if multipart %}{% set type_annotation = type_annotation | replace("str", "bytes") %}{% endif %}
 {{ destination }}: {{ type_annotation }} = UNSET
 {% else %}
 {{ destination }} = UNSET
@@ -29,3 +25,15 @@ if not isinstance({{ source }}, Unset):
     {{ destination }} = {{ transformed }}
 {%- endif %}
 {% endmacro %}
+
+{% macro transform_multipart(property, source, destination) %}
+{% set transformed = source + ".isoformat().encode()" %}
+{% if property.required %}
+{{ destination }} = {{ transformed }}
+{%- else %}
+{% set type_annotation = property.get_type_string(json=True) | replace("str", "bytes") %}
+{{ destination }}: {{ type_annotation }} = UNSET
+if not isinstance({{ source }}, Unset):
+    {{ destination }} = {{ transformed }}
+{%- endif %}
+{% endmacro %}

{openapi_python_client-0.19.1 → openapi_python_client-0.21.0}/openapi_python_client/templates/property_templates/enum_property.py.jinja

@@ -13,10 +13,6 @@
 {% macro transform(property, source, destination, declare_type=True, multipart=False) %}
 {% set transformed = source + ".value" %}
 {% set type_string = property.get_type_string(json=True) %}
-{% if multipart %}
-    {% set transformed = "(None, str(" + transformed + ").encode(), \"text/plain\")" %}
-    {% set type_string = "Union[Unset, Tuple[None, bytes, str]]" %}
-{% endif %}
 {% if property.required %}
 {{ destination }} = {{ transformed }}
 {%- else %}
@@ -26,6 +22,18 @@ if not isinstance({{ source }}, Unset):
 {% endif %}
 {% endmacro %}
 
+{% macro transform_multipart(property, source, destination) %}
+{% set transformed = "(None, str(" + source + ".value" + ").encode(), \"text/plain\")" %}
+{% set type_string = "Union[Unset, Tuple[None, bytes, str]]" %}
+{% if property.required %}
+{{ destination }} = {{ transformed }}
+{%- else %}
+{{ destination }}: {{ type_string }} = UNSET
+if not isinstance({{ source }}, Unset):
+    {{ destination }} = {{ transformed }}
+{% endif %}
+{% endmacro %}
+
 {% macro transform_header(source) %}
 str({{ source }})
 {% endmacro %}

{openapi_python_client-0.19.1 → openapi_python_client-0.21.0}/openapi_python_client/templates/property_templates/file_property.py.jinja

@@ -12,7 +12,7 @@ File(
 
 {% macro check_type_for_construct(property, source) %}isinstance({{ source }}, bytes){% endmacro %}
 
-{% macro transform(property, source, destination, declare_type=True, multipart=False) %}
+{% macro transform(property, source, destination, declare_type=True) %}
 {% if property.required %}
 {{ destination }} = {{ source }}.to_tuple()
 {% else %}
@@ -21,3 +21,13 @@ if not isinstance({{ source }}, Unset):
     {{ destination }} = {{ source }}.to_tuple()
 {% endif %}
 {% endmacro %}
+
+{% macro transform_multipart(property, source, destination) %}
+{% if property.required %}
+{{ destination }} = {{ source }}.to_tuple()
+{% else %}
+{{ destination }}: {{ property.get_type_string(json=True) }} = UNSET
+if not isinstance({{ source }}, Unset):
+    {{ destination }} = {{ source }}.to_tuple()
+{% endif %}
+{% endmacro %}