openapi-python-client 0.26.2__tar.gz → 0.27.1__tar.gz

{openapi_python_client-0.26.2 → openapi_python_client-0.27.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openapi-python-client
-Version: 0.26.2
+Version: 0.27.1
 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>
@@ -11,14 +11,14 @@ Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Code Generators
 Classifier: Typing :: Typed
-Requires-Python: <4.0,>=3.9
+Requires-Python: <4.0,>=3.10
 Requires-Dist: attrs>=22.2.0
 Requires-Dist: colorama>=0.4.3; sys_platform == 'win32'
 Requires-Dist: httpx<0.29.0,>=0.23.0
@@ -26,10 +26,9 @@ Requires-Dist: jinja2<4.0.0,>=3.0.0
 Requires-Dist: pydantic<3.0.0,>=2.10
 Requires-Dist: python-dateutil<3.0.0,>=2.8.1
 Requires-Dist: ruamel-yaml<0.19.0,>=0.18.6
-Requires-Dist: ruff<0.14,>=0.2
+Requires-Dist: ruff>=0.2
 Requires-Dist: shellingham<2.0.0,>=1.3.2
-Requires-Dist: typer<0.20,>0.6
-Requires-Dist: typing-extensions<5.0.0,>=4.8.0
+Requires-Dist: typer<0.21,>0.16
 Description-Content-Type: text/markdown
 
 ![Run Checks](https://github.com/openapi-generators/openapi-python-client/workflows/Run%20Checks/badge.svg)
@@ -200,7 +199,7 @@ In the config file, there's an easy way to tell `openapi-python-client` to run a
 
 ```yaml
 post_hooks:
-   - "ruff check . --fix"
+   - "ruff check . --fix-only"
    - "ruff format ."
 ```
 

{openapi_python_client-0.26.2 → openapi_python_client-0.27.1}/README.md

@@ -166,7 +166,7 @@ In the config file, there's an easy way to tell `openapi-python-client` to run a
 
 ```yaml
 post_hooks:
-   - "ruff check . --fix"
+   - "ruff check . --fix-only"
    - "ruff format ."
 ```
 

{openapi_python_client-0.26.2 → openapi_python_client-0.27.1}/openapi_python_client/__init__.py

@@ -8,7 +8,7 @@ from collections.abc import Sequence
 from importlib.metadata import version
 from pathlib import Path
 from subprocess import CalledProcessError
-from typing import Any, Optional, Union
+from typing import Any
 
 import httpcore
 import httpx
@@ -42,7 +42,7 @@ class Project:
         *,
         openapi: GeneratorData,
         config: Config,
-        custom_template_path: Optional[Path] = None,
+        custom_template_path: Path | None = None,
     ) -> None:
         self.openapi: GeneratorData = openapi
         self.config = config
@@ -292,8 +292,8 @@ class Project:
 
 def _get_project_for_url_or_path(
     config: Config,
-    custom_template_path: Optional[Path] = None,
-) -> Union[Project, GeneratorError]:
+    custom_template_path: Path | None = None,
+) -> Project | GeneratorError:
     data_dict = _get_document(source=config.document_source, timeout=config.http_timeout)
     if isinstance(data_dict, GeneratorError):
         return data_dict
@@ -310,7 +310,7 @@ def _get_project_for_url_or_path(
 def generate(
     *,
     config: Config,
-    custom_template_path: Optional[Path] = None,
+    custom_template_path: Path | None = None,
 ) -> Sequence[GeneratorError]:
     """
     Generate the client library
@@ -327,7 +327,7 @@ def generate(
     return project.build()
 
 
-def _load_yaml_or_json(data: bytes, content_type: Optional[str]) -> Union[dict[str, Any], GeneratorError]:
+def _load_yaml_or_json(data: bytes, content_type: str | None) -> dict[str, Any] | GeneratorError:
     if content_type == "application/json":
         try:
             return json.loads(data.decode())
@@ -341,9 +341,9 @@ def _load_yaml_or_json(data: bytes, content_type: Optional[str]) -> Union[dict[s
             return GeneratorError(header=f"Invalid YAML from provided source: {err}")
 
 
-def _get_document(*, source: Union[str, Path], timeout: int) -> Union[dict[str, Any], GeneratorError]:
+def _get_document(*, source: str | Path, timeout: int) -> dict[str, Any] | GeneratorError:
     yaml_bytes: bytes
-    content_type: Optional[str]
+    content_type: str | None
     if isinstance(source, str):
         try:
             response = httpx.get(source, timeout=timeout)

{openapi_python_client-0.26.2 → openapi_python_client-0.27.1}/openapi_python_client/cli.py

@@ -2,7 +2,6 @@ import codecs
 from collections.abc import Sequence
 from pathlib import Path
 from pprint import pformat
-from typing import Optional, Union
 
 import typer
 
@@ -21,15 +20,15 @@ def _version_callback(value: bool) -> None:
 
 def _process_config(
     *,
-    url: Optional[str],
-    path: Optional[Path],
-    config_path: Optional[Path],
+    url: str | None,
+    path: Path | None,
+    config_path: Path | None,
     meta_type: MetaType,
     file_encoding: str,
     overwrite: bool,
-    output_path: Optional[Path],
+    output_path: Path | None,
 ) -> Config:
-    source: Union[Path, str]
+    source: Path | str
     if url and not path:
         source = url
     elif path and not url:
@@ -70,16 +69,16 @@ def cli(
 
 def _print_parser_error(err: GeneratorError, color: str) -> None:
     typer.secho(err.header, bold=True, fg=color, err=True)
-    typer.echo()
+    typer.echo(err=True)
     if err.detail:
         typer.secho(err.detail, fg=color, err=True)
-        typer.echo()
+        typer.echo(err=True)
 
     if isinstance(err, ParseError) and err.data is not None:
         formatted_data = pformat(err.data)
         typer.secho(formatted_data, fg=color, err=True)
 
-    typer.echo()
+    typer.echo(err=True)
 
 
 def handle_errors(errors: Sequence[GeneratorError], fail_on_warning: bool = False) -> None:
@@ -125,9 +124,9 @@ def handle_errors(errors: Sequence[GeneratorError], fail_on_warning: bool = Fals
 
 @app.command()
 def generate(
-    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(
+    url: str | None = typer.Option(None, help="A URL to read the OpenAPI document from"),
+    path: Path | None = typer.Option(None, help="A path to the OpenAPI document"),
+    custom_template_path: Path | None = typer.Option(
         None,
         help="A path to a directory containing custom template(s)",
         file_okay=False,
@@ -140,10 +139,10 @@ def generate(
         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] = typer.Option(None, "--config", help="Path to the config file to use"),
+    config_path: Path | None = 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(
+    output_path: Path | None = 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). "

{openapi_python_client-0.26.2 → openapi_python_client-0.27.1}/openapi_python_client/config.py

@@ -2,7 +2,6 @@ import json
 import mimetypes
 from enum import Enum
 from pathlib import Path
-from typing import Optional, Union
 
 from attr import define
 from pydantic import BaseModel
@@ -15,8 +14,8 @@ class ClassOverride(BaseModel):
     See https://github.com/openapi-generators/openapi-python-client#class_overrides
     """
 
-    class_name: Optional[str] = None
-    module_name: Optional[str] = None
+    class_name: str | None = None
+    module_name: str | None = None
 
 
 class MetaType(str, Enum):
@@ -35,13 +34,13 @@ class ConfigFile(BaseModel):
     See https://github.com/openapi-generators/openapi-python-client#configuration
     """
 
-    class_overrides: Optional[dict[str, ClassOverride]] = None
-    content_type_overrides: Optional[dict[str, str]] = None
-    project_name_override: Optional[str] = None
-    package_name_override: Optional[str] = None
-    package_version_override: Optional[str] = None
+    class_overrides: dict[str, ClassOverride] | None = None
+    content_type_overrides: dict[str, str] | None = None
+    project_name_override: str | None = None
+    package_name_override: str | None = None
+    package_version_override: str | None = None
     use_path_prefixes_for_title_model_names: bool = True
-    post_hooks: Optional[list[str]] = None
+    post_hooks: list[str] | None = None
     docstrings_on_attributes: bool = False
     field_prefix: str = "field_"
     generate_all_tags: bool = False
@@ -67,9 +66,9 @@ class Config:
 
     meta_type: MetaType
     class_overrides: dict[str, ClassOverride]
-    project_name_override: Optional[str]
-    package_name_override: Optional[str]
-    package_version_override: Optional[str]
+    project_name_override: str | None
+    package_name_override: str | None
+    package_version_override: str | None
     use_path_prefixes_for_title_model_names: bool
     post_hooks: list[str]
     docstrings_on_attributes: bool
@@ -77,31 +76,31 @@ class Config:
     generate_all_tags: bool
     http_timeout: int
     literal_enums: bool
-    document_source: Union[Path, str]
+    document_source: Path | str
     file_encoding: str
     content_type_overrides: dict[str, str]
     overwrite: bool
-    output_path: Optional[Path]
+    output_path: Path | None
 
     @staticmethod
     def from_sources(
         config_file: ConfigFile,
         meta_type: MetaType,
-        document_source: Union[Path, str],
+        document_source: Path | str,
         file_encoding: str,
         overwrite: bool,
-        output_path: Optional[Path],
+        output_path: Path | None,
     ) -> "Config":
         if config_file.post_hooks is not None:
             post_hooks = config_file.post_hooks
         elif meta_type == MetaType.NONE:
             post_hooks = [
-                "ruff check . --fix --extend-select=I",
+                "ruff check . --fix-only --extend-select=I",
                 "ruff format .",
             ]
         else:
             post_hooks = [
-                "ruff check --fix .",
+                "ruff check --fix-only .",
                 "ruff format .",
             ]
 

{openapi_python_client-0.26.2 → openapi_python_client-0.27.1}/openapi_python_client/parser/bodies.py

@@ -1,5 +1,4 @@
 import sys
-from typing import Union
 
 import attr
 
@@ -45,10 +44,10 @@ def body_from_data(
     *,
     data: oai.Operation,
     schemas: Schemas,
-    request_bodies: dict[str, Union[oai.RequestBody, oai.Reference]],
+    request_bodies: dict[str, oai.RequestBody | oai.Reference],
     config: Config,
     endpoint_name: str,
-) -> tuple[list[Union[Body, ParseError]], Schemas]:
+) -> tuple[list[Body | ParseError], Schemas]:
     """Adds form or JSON body to Endpoint if included in data"""
     body = _resolve_reference(data.request_body, request_bodies)
     if isinstance(body, ParseError):
@@ -56,7 +55,7 @@ def body_from_data(
     if body is None:
         return [], schemas
 
-    bodies: list[Union[Body, ParseError]] = []
+    bodies: list[Body | ParseError] = []
     body_content = body.content
     prefix_type_names = len(body_content) > 1
 
@@ -132,8 +131,8 @@ def body_from_data(
 
 
 def _resolve_reference(
-    body: Union[oai.RequestBody, oai.Reference, None], request_bodies: dict[str, Union[oai.RequestBody, oai.Reference]]
-) -> Union[oai.RequestBody, ParseError, None]:
+    body: oai.RequestBody | oai.Reference | None, request_bodies: dict[str, oai.RequestBody | oai.Reference]
+) -> oai.RequestBody | ParseError | None:
     if body is None:
         return None
     references_seen = []

{openapi_python_client-0.26.2 → openapi_python_client-0.27.1}/openapi_python_client/parser/errors.py

@@ -1,6 +1,5 @@
 from dataclasses import dataclass
 from enum import Enum
-from typing import Optional
 
 __all__ = ["ErrorLevel", "GeneratorError", "ParameterError", "ParseError", "PropertyError"]
 
@@ -18,7 +17,7 @@ class ErrorLevel(Enum):
 class GeneratorError:
     """Base data struct containing info on an error that occurred"""
 
-    detail: Optional[str] = None
+    detail: str | None = None
     level: ErrorLevel = ErrorLevel.ERROR
     header: str = "Unable to generate the client"
 
@@ -28,7 +27,7 @@ class ParseError(GeneratorError):
     """An error raised when there's a problem parsing an OpenAPI document"""
 
     level: ErrorLevel = ErrorLevel.WARNING
-    data: Optional[BaseModel] = None
+    data: BaseModel | None = None
     header: str = "Unable to parse this part of your OpenAPI document: "
 
 

{openapi_python_client-0.26.2 → openapi_python_client-0.27.1}/openapi_python_client/parser/openapi.py

@@ -2,7 +2,7 @@ import re
 from collections.abc import Iterator
 from copy import deepcopy
 from dataclasses import dataclass, field
-from typing import Any, Optional, Protocol, Union
+from typing import Any, Protocol
 
 from pydantic import ValidationError
 
@@ -49,8 +49,8 @@ class EndpointCollection:
         data: dict[str, oai.PathItem],
         schemas: Schemas,
         parameters: Parameters,
-        request_bodies: dict[str, Union[oai.RequestBody, oai.Reference]],
-        responses: dict[str, Union[oai.Response, oai.Reference]],
+        request_bodies: dict[str, oai.RequestBody | oai.Reference],
+        responses: dict[str, oai.Response | oai.Reference],
         config: Config,
     ) -> tuple[dict[utils.PythonIdentifier, "EndpointCollection"], Schemas, Parameters]:
         """Parse the openapi paths data to get EndpointCollections by tag"""
@@ -60,7 +60,7 @@ class EndpointCollection:
 
         for path, path_data in data.items():
             for method in methods:
-                operation: Optional[oai.Operation] = getattr(path_data, method)
+                operation: oai.Operation | None = getattr(path_data, method)
                 if operation is None:
                     continue
 
@@ -125,7 +125,7 @@ class RequestBodyParser(Protocol):
 
     def __call__(
         self, *, body: oai.RequestBody, schemas: Schemas, parent_name: str, config: Config
-    ) -> tuple[Union[Property, PropertyError, None], Schemas]: ...  # pragma: no cover
+    ) -> tuple[Property | PropertyError | None, Schemas]: ...  # pragma: no cover
 
 
 @dataclass
@@ -136,11 +136,11 @@ class Endpoint:
 
     path: str
     method: str
-    description: Optional[str]
+    description: str | None
     name: str
     requires_security: bool
     tags: list[PythonIdentifier]
-    summary: Optional[str] = ""
+    summary: str | None = ""
     relative_imports: set[str] = field(default_factory=set)
     query_parameters: list[Property] = field(default_factory=list)
     path_parameters: list[Property] = field(default_factory=list)
@@ -156,7 +156,7 @@ class Endpoint:
         endpoint: "Endpoint",
         data: oai.Responses,
         schemas: Schemas,
-        responses: dict[str, Union[oai.Response, oai.Reference]],
+        responses: dict[str, oai.Response | oai.Reference],
         config: Config,
     ) -> tuple["Endpoint", Schemas]:
         endpoint = deepcopy(endpoint)
@@ -201,11 +201,11 @@ class Endpoint:
     def add_parameters(
         *,
         endpoint: "Endpoint",
-        data: Union[oai.Operation, oai.PathItem],
+        data: oai.Operation | oai.PathItem,
         schemas: Schemas,
         parameters: Parameters,
         config: Config,
-    ) -> tuple[Union["Endpoint", ParseError], Schemas, Parameters]:
+    ) -> tuple["Endpoint | ParseError", Schemas, Parameters]:
         """Process the defined `parameters` for an Endpoint.
 
         Any existing parameters will be ignored, so earlier instances of a parameter take precedence. PathItem
@@ -312,8 +312,8 @@ class Endpoint:
         self,
         *,
         config: Config,
-        previously_modified_params: Optional[set[tuple[oai.ParameterLocation, str]]] = None,
-    ) -> Union["Endpoint", ParseError]:
+        previously_modified_params: set[tuple[oai.ParameterLocation, str]] | None = None,
+    ) -> "Endpoint | ParseError":
         """Check for conflicting parameters
 
         For parameters that have the same python_name but are in different locations, append the location to the
@@ -366,7 +366,7 @@ class Endpoint:
         return self
 
     @staticmethod
-    def sort_parameters(*, endpoint: "Endpoint") -> Union["Endpoint", ParseError]:
+    def sort_parameters(*, endpoint: "Endpoint") -> "Endpoint | ParseError":
         """
         Sorts the path parameters of an `endpoint` so that they match the order declared in `endpoint.path`.
 
@@ -403,10 +403,10 @@ class Endpoint:
         tags: list[PythonIdentifier],
         schemas: Schemas,
         parameters: Parameters,
-        request_bodies: dict[str, Union[oai.RequestBody, oai.Reference]],
-        responses: dict[str, Union[oai.Response, oai.Reference]],
+        request_bodies: dict[str, oai.RequestBody | oai.Reference],
+        responses: dict[str, oai.Response | oai.Reference],
         config: Config,
-    ) -> tuple[Union["Endpoint", ParseError], Schemas, Parameters]:
+    ) -> tuple["Endpoint | ParseError", Schemas, Parameters]:
         """Construct an endpoint from the OpenAPI data"""
 
         if data.operationId is None:
@@ -469,12 +469,12 @@ class Endpoint:
 
     def response_type(self) -> str:
         """Get the Python type of any response from this endpoint"""
-        types = sorted({response.prop.get_type_string(quoted=False) for response in self.responses})
+        types = sorted({response.prop.get_type_string() for response in self.responses})
         if len(types) == 0:
             return "Any"
         if len(types) == 1:
             return types[0]
-        return f"Union[{', '.join(types)}]"
+        return " | ".join(types)
 
     def iter_all_parameters(self) -> Iterator[tuple[oai.ParameterLocation, Property]]:
         """Iterate through all the parameters of this endpoint"""
@@ -499,15 +499,15 @@ class GeneratorData:
     """All the data needed to generate a client"""
 
     title: str
-    description: Optional[str]
+    description: str | None
     version: str
     models: list[ModelProperty]
     errors: list[ParseError]
     endpoint_collections_by_tag: dict[utils.PythonIdentifier, EndpointCollection]
-    enums: list[Union[EnumProperty, LiteralEnumProperty]]
+    enums: list[EnumProperty | LiteralEnumProperty]
 
     @staticmethod
-    def from_dict(data: dict[str, Any], *, config: Config) -> Union["GeneratorData", GeneratorError]:
+    def from_dict(data: dict[str, Any], *, config: Config) -> "GeneratorData | GeneratorError":
         """Create an OpenAPI from dict"""
         try:
             openapi = oai.OpenAPI.model_validate(data)
@@ -540,7 +540,7 @@ class GeneratorData:
         )
 
         enums = [
-            prop for prop in schemas.classes_by_name.values() if isinstance(prop, (EnumProperty, LiteralEnumProperty))
+            prop for prop in schemas.classes_by_name.values() if isinstance(prop, EnumProperty | LiteralEnumProperty)
         ]
         models = [prop for prop in schemas.classes_by_name.values() if isinstance(prop, ModelProperty)]
 

{openapi_python_client-0.26.2 → openapi_python_client-0.27.1}/openapi_python_client/parser/properties/const.py

@@ -93,12 +93,10 @@ class ConstProperty(PropertyProtocol):
         self,
         no_optional: bool = False,
         json: bool = False,
-        *,
-        quoted: bool = False,
     ) -> str:
         lit = f"Literal[{self.value.python_code}]"
         if not no_optional and not self.required:
-            return f"Union[{lit}, Unset]"
+            return f"{lit} | Unset"
         return lit
 
     def get_imports(self, *, prefix: str) -> set[str]:
@@ -112,6 +110,6 @@ class ConstProperty(PropertyProtocol):
         if self.required:
             return {"from typing import Literal, cast"}
         return {
-            "from typing import Literal, Union, cast",
+            "from typing import Literal, cast",
             f"from {prefix}types import UNSET, Unset",
         }

{openapi_python_client-0.26.2 → openapi_python_client-0.27.1}/openapi_python_client/parser/properties/enum_property.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 __all__ = ["EnumProperty", "ValueType"]
 
-from typing import Any, ClassVar, Union, cast
+from typing import Any, ClassVar, cast
 
 from attr import evolve
 from attrs import define
@@ -16,7 +16,7 @@ from .protocol import PropertyProtocol, Value
 from .schemas import Class, Schemas
 from .union import UnionProperty
 
-ValueType = Union[str, int]
+ValueType = str | int
 
 
 @define
@@ -98,9 +98,7 @@ class EnumProperty(PropertyProtocol):
         value_type = next(iter(value_types))
         if value_type not in (str, int):
             return PropertyError(header=f"Unsupported enum type {value_type}", data=data), schemas
-        value_list = cast(
-            Union[list[int], list[str]], unchecked_value_list
-        )  # We checked this with all the value_types stuff
+        value_list = cast(list[int] | list[str], unchecked_value_list)  # We checked this with all the value_types stuff
 
         if len(value_list) < len(enum):  # Only one of the values was None, that becomes a union
             data.oneOf = [
@@ -165,10 +163,10 @@ class EnumProperty(PropertyProtocol):
                 return PropertyError(detail=f"Value {value} is not valid for enum {self.name}")
         return PropertyError(detail=f"Cannot convert {value} to enum {self.name} of type {self.value_type}")
 
-    def get_base_type_string(self, *, quoted: bool = False) -> str:
+    def get_base_type_string(self) -> str:
         return self.class_info.name
 
-    def get_base_json_type_string(self, *, quoted: bool = False) -> str:
+    def get_base_json_type_string(self) -> str:
         return self.value_type.__name__
 
     def get_imports(self, *, prefix: str) -> set[str]:
@@ -192,7 +190,7 @@ class EnumProperty(PropertyProtocol):
         use_var_names = len(var_names) == len(values)
 
         for i, value in enumerate(values):
-            value = cast(Union[str, int], value)
+            value = cast(str | int, value)
             if isinstance(value, int):
                 if use_var_names:
                     key = var_names[i]

{openapi_python_client-0.26.2 → openapi_python_client-0.27.1}/openapi_python_client/parser/properties/list_property.py

@@ -105,11 +105,11 @@ class ListProperty(PropertyProtocol):
     def convert_value(self, value: Any) -> Value | None | PropertyError:
         return None  # pragma: no cover
 
-    def get_base_type_string(self, *, quoted: bool = False) -> str:
-        return f"list[{self.inner_property.get_type_string(quoted=not self.inner_property.is_base_type)}]"
+    def get_base_type_string(self) -> str:
+        return f"list[{self.inner_property.get_type_string()}]"
 
-    def get_base_json_type_string(self, *, quoted: bool = False) -> str:
-        return f"list[{self.inner_property.get_type_string(json=True, quoted=not self.inner_property.is_base_type)}]"
+    def get_base_json_type_string(self) -> str:
+        return f"list[{self.inner_property.get_type_string(json=True)}]"
 
     def get_instance_type_string(self) -> str:
         """Get a string representation of runtime type that should be used for `isinstance` checks"""
@@ -137,8 +137,6 @@ class ListProperty(PropertyProtocol):
         self,
         no_optional: bool = False,
         json: bool = False,
-        *,
-        quoted: bool = False,
     ) -> str:
         """
         Get a string representation of type that should be used when declaring this property
@@ -154,4 +152,4 @@ class ListProperty(PropertyProtocol):
 
         if no_optional or self.required:
             return type_string
-        return f"Union[Unset, {type_string}]"
+        return f"{type_string} | Unset"

{openapi_python_client-0.26.2 → openapi_python_client-0.27.1}/openapi_python_client/parser/properties/literal_enum_property.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 __all__ = ["LiteralEnumProperty"]
 
-from typing import Any, ClassVar, Union, cast
+from typing import Any, ClassVar, cast
 
 from attr import evolve
 from attrs import define
@@ -16,7 +16,7 @@ from .protocol import PropertyProtocol, Value
 from .schemas import Class, Schemas
 from .union import UnionProperty
 
-ValueType = Union[str, int]
+ValueType = str | int
 
 
 @define
@@ -97,9 +97,7 @@ class LiteralEnumProperty(PropertyProtocol):
         value_type = next(iter(value_types))
         if value_type not in (str, int):
             return PropertyError(header=f"Unsupported enum type {value_type}", data=data), schemas
-        value_list = cast(
-            Union[list[int], list[str]], unchecked_value_list
-        )  # We checked this with all the value_types stuff
+        value_list = cast(list[int] | list[str], unchecked_value_list)  # We checked this with all the value_types stuff
 
         if len(value_list) < len(enum):  # Only one of the values was None, that becomes a union
             data.oneOf = [
@@ -162,10 +160,10 @@ class LiteralEnumProperty(PropertyProtocol):
                 return PropertyError(detail=f"Value {value} is not valid for enum {self.name}")
         return PropertyError(detail=f"Cannot convert {value} to enum {self.name} of type {self.value_type}")
 
-    def get_base_type_string(self, *, quoted: bool = False) -> str:
+    def get_base_type_string(self) -> str:
         return self.class_info.name
 
-    def get_base_json_type_string(self, *, quoted: bool = False) -> str:
+    def get_base_json_type_string(self) -> str:
         return self.value_type.__name__
 
     def get_instance_type_string(self) -> str:

{openapi_python_client-0.26.2 → openapi_python_client-0.27.1}/openapi_python_client/parser/properties/merge_properties.py

@@ -105,9 +105,9 @@ def _merge_string_with_format(prop1: Property, prop2: Property) -> Property | No
 
 def _merge_numeric(prop1: Property, prop2: Property) -> IntProperty | None | PropertyError:
     """Merge IntProperty with FloatProperty"""
-    if isinstance(prop1, IntProperty) and isinstance(prop2, (IntProperty, FloatProperty)):
+    if isinstance(prop1, IntProperty) and isinstance(prop2, IntProperty | FloatProperty):
         return _merge_common_attributes(prop1, prop2)
-    elif isinstance(prop2, IntProperty) and isinstance(prop1, (IntProperty, FloatProperty)):
+    elif isinstance(prop2, IntProperty) and isinstance(prop1, IntProperty | FloatProperty):
         # Use the IntProperty as a base since it's more restrictive, but keep the correct override order
         return _merge_common_attributes(prop2, prop1, prop2)
     else: