aidial-client 0.11.0.dev1__tar.gz → 0.11.0.dev2__tar.gz

{aidial_client-0.11.0.dev1 → aidial_client-0.11.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aidial-client
-Version: 0.11.0.dev1
+Version: 0.11.0.dev2
 Summary: A Python client library for the AI DIAL API
 License-Expression: Apache-2.0
 License-File: LICENSE

{aidial_client-0.11.0.dev1 → aidial_client-0.11.0.dev2}/aidial_client/_auth.py

@@ -1,12 +1,13 @@
+from collections.abc import Awaitable, Callable
 from inspect import isawaitable
-from typing import Awaitable, Callable, Dict, Optional, TypeVar, Union
+from typing import TypeVar
 
-SyncAuthValue = Union[str, Callable[[], str]]
-AsyncAuthValue = Union[SyncAuthValue, Callable[[], Awaitable[str]]]
+SyncAuthValue = str | Callable[[], str]
+AsyncAuthValue = SyncAuthValue | Callable[[], Awaitable[str]]
 
 AuthValueT = TypeVar(
     "AuthValueT",
-    bound=Union[SyncAuthValue, AsyncAuthValue],
+    bound=SyncAuthValue | AsyncAuthValue,
 )
 
 
@@ -20,7 +21,8 @@ def get_auth_value(auth_value: SyncAuthValue) -> str:
     if TYPE_CHECKING:
         assert_never(auth_value)
     raise TypeError(
-        f"auth_value must be a string or a callable returning a string, got {type(auth_value).__name__}"
+        f"auth_value must be a string or a callable returning a string, "
+        f"got {type(auth_value).__name__}"
     )
 
 
@@ -35,16 +37,17 @@ async def aget_auth_value(auth_value: AsyncAuthValue) -> str:
     if TYPE_CHECKING:
         assert_never(auth_value)
     raise TypeError(
-        f"auth_value must be a string or a callable, got {type(auth_value).__name__}"
+        "auth_value must be a string or a callable, "
+        f"got {type(auth_value).__name__}"
     )
 
 
 def get_combined_auth_headers(
     *,
-    api_key: Optional[SyncAuthValue] = None,
-    bearer_token: Optional[SyncAuthValue] = None,
-) -> Dict[str, str]:
-    headers: Dict[str, str] = {}
+    api_key: SyncAuthValue | None = None,
+    bearer_token: SyncAuthValue | None = None,
+) -> dict[str, str]:
+    headers: dict[str, str] = {}
 
     if api_key is not None:
         headers["api-key"] = get_auth_value(api_key)
@@ -58,11 +61,14 @@ def get_combined_auth_headers(
 
 async def aget_combined_auth_headers(
     *,
-    api_key: Optional[AsyncAuthValue] = None,
-    bearer_token: Optional[AsyncAuthValue] = None,
-) -> Dict[str, str]:
-    """Get combined authentication headers from both api_key and bearer_token (async)."""
-    headers: Dict[str, str] = {}
+    api_key: AsyncAuthValue | None = None,
+    bearer_token: AsyncAuthValue | None = None,
+) -> dict[str, str]:
+    """
+    Get combined authentication headers from both api_key and
+    bearer_token (async).
+    """
+    headers: dict[str, str] = {}
 
     if api_key is not None:
         processed_api_key = await aget_auth_value(api_key)
@@ -77,8 +83,8 @@ async def aget_combined_auth_headers(
 
 def validate_auth(
     *,
-    api_key: Optional[AsyncAuthValue] = None,
-    bearer_token: Optional[AsyncAuthValue] = None,
+    api_key: AsyncAuthValue | None = None,
+    bearer_token: AsyncAuthValue | None = None,
 ) -> None:
     """Validate that at least one authentication method is provided."""
     if not api_key and not bearer_token:

{aidial_client-0.11.0.dev1 → aidial_client-0.11.0.dev2}/aidial_client/_client.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from pathlib import PurePosixPath
-from typing import Dict, Generic, Optional, TypeVar, Union
+from typing import Generic, TypeVar
 from urllib.parse import urljoin
 
 import openai
@@ -24,30 +24,28 @@ from aidial_client._internal_types._defaults import NOT_GIVEN, NotGiven
 from aidial_client.helpers._url import enforce_trailing_slash
 from aidial_client.types.bucket import AppData
 
-_HttpClientT = TypeVar(
-    "_HttpClientT", bound=Union[AsyncHTTPClient, SyncHTTPClient]
-)
+_HttpClientT = TypeVar("_HttpClientT", bound=AsyncHTTPClient | SyncHTTPClient)
 
 
 class BaseDialClient(Generic[_HttpClientT, AuthValueT], ABC):
-    _api_key: Optional[AuthValueT]
-    _bearer_token: Optional[AuthValueT]
+    _api_key: AuthValueT | None
+    _bearer_token: AuthValueT | None
     _base_url: str
     _http_client: _HttpClientT
-    _auth_headers: Dict[str, str]
-    _my_bucket: Optional[str]
-    _my_appdata: Union[AppData, None, NotGiven]
+    _auth_headers: dict[str, str]
+    _my_bucket: str | None
+    _my_appdata: AppData | None | NotGiven
 
     def __init__(
         self,
         *,
         base_url: str,
-        api_key: Optional[AuthValueT] = None,
-        bearer_token: Optional[AuthValueT] = None,
+        api_key: AuthValueT | None = None,
+        bearer_token: AuthValueT | None = None,
         max_retries: int = DEFAULT_MAX_RETRIES,
-        timeout: Union[float, Timeout, None] = DEFAULT_TIMEOUT,
-        api_version: Optional[str] = None,
-        http_client: Optional[_HttpClientT] = None,
+        timeout: float | Timeout | None = DEFAULT_TIMEOUT,
+        api_version: str | None = None,
+        http_client: _HttpClientT | None = None,
     ):
         validate_auth(api_key=api_key, bearer_token=bearer_token)
         self._api_key = api_key
@@ -79,12 +77,11 @@ class BaseDialClient(Generic[_HttpClientT, AuthValueT], ABC):
         return self._base_url
 
     @property
-    def api_version(self) -> Optional[str]:
+    def api_version(self) -> str | None:
         return self._api_version
 
 
 class Dial(BaseDialClient[SyncHTTPClient, SyncAuthValue]):
-
     def _init_resources(self) -> None:
         openai_client = openai.AzureOpenAI(
             api_key="-",
@@ -150,26 +147,25 @@ class Dial(BaseDialClient[SyncHTTPClient, SyncAuthValue]):
     def my_prompts_home(self) -> PurePosixPath:
         return "prompts" / PurePosixPath(self.my_bucket())
 
-    def _get_my_appdata(self) -> Optional[AppData]:
+    def _get_my_appdata(self) -> AppData | None:
         return self.bucket.get_appdata()
 
-    def my_appdata(self) -> Optional[AppData]:
+    def my_appdata(self) -> AppData | None:
         if isinstance(self._my_appdata, NotGiven):
             self._my_appdata = self._get_my_appdata()
         return self._my_appdata
 
-    def my_appdata_home(self) -> Optional[PurePosixPath]:
+    def my_appdata_home(self) -> PurePosixPath | None:
         appdata = self.my_appdata()
         if appdata:
             return PurePosixPath(appdata.raw)
         return None
 
-    def auth_headers(self) -> Dict[str, str]:
+    def auth_headers(self) -> dict[str, str]:
         return self._http_client.auth_headers()
 
 
 class AsyncDial(BaseDialClient[AsyncHTTPClient, AsyncAuthValue]):
-
     def _init_resources(self) -> None:
         openai_client = openai.AsyncAzureOpenAI(
             api_key="-",
@@ -241,19 +237,19 @@ class AsyncDial(BaseDialClient[AsyncHTTPClient, AsyncAuthValue]):
     async def my_prompts_home(self) -> PurePosixPath:
         return "prompts" / PurePosixPath(await self.my_bucket())
 
-    async def _get_my_appdata(self) -> Optional[AppData]:
+    async def _get_my_appdata(self) -> AppData | None:
         return await self.bucket.get_appdata()
 
-    async def my_appdata(self) -> Optional[AppData]:
+    async def my_appdata(self) -> AppData | None:
         if isinstance(self._my_appdata, NotGiven):
             self._my_appdata = await self._get_my_appdata()
         return self._my_appdata
 
-    async def my_appdata_home(self) -> Optional[PurePosixPath]:
+    async def my_appdata_home(self) -> PurePosixPath | None:
         appdata = await self.my_appdata()
         if appdata:
             return PurePosixPath(appdata.raw)
         return None
 
-    async def auth_headers(self) -> Dict[str, str]:
+    async def auth_headers(self) -> dict[str, str]:
         return await self._http_client.auth_headers()

{aidial_client-0.11.0.dev1 → aidial_client-0.11.0.dev2}/aidial_client/_client_pool.py

@@ -1,5 +1,3 @@
-from typing import Optional, Union
-
 import httpx
 
 from aidial_client._auth import AsyncAuthValue, SyncAuthValue
@@ -27,10 +25,10 @@ class DialClientPool:
         self,
         *,
         base_url: str,
-        api_key: Optional[SyncAuthValue] = None,
-        bearer_token: Optional[SyncAuthValue] = None,
+        api_key: SyncAuthValue | None = None,
+        bearer_token: SyncAuthValue | None = None,
         max_retries: int = DEFAULT_MAX_RETRIES,
-        timeout: Union[httpx.Timeout, float] = DEFAULT_TIMEOUT,
+        timeout: httpx.Timeout | float = DEFAULT_TIMEOUT,
     ) -> Dial:
         return Dial(
             base_url=base_url,
@@ -62,10 +60,10 @@ class AsyncDialClientPool:
         self,
         *,
         base_url: str,
-        api_key: Optional[AsyncAuthValue] = None,
-        bearer_token: Optional[AsyncAuthValue] = None,
+        api_key: AsyncAuthValue | None = None,
+        bearer_token: AsyncAuthValue | None = None,
         max_retries: int = DEFAULT_MAX_RETRIES,
-        timeout: Union[httpx.Timeout, float] = DEFAULT_TIMEOUT,
+        timeout: httpx.Timeout | float = DEFAULT_TIMEOUT,
     ) -> AsyncDial:
         return AsyncDial(
             base_url=base_url,

{aidial_client-0.11.0.dev1 → aidial_client-0.11.0.dev2}/aidial_client/_exception.py

@@ -1,5 +1,5 @@
+from collections.abc import Mapping
 from http import HTTPStatus
-from typing import Mapping, Optional
 
 
 class DialException(Exception):
@@ -7,10 +7,10 @@ class DialException(Exception):
         self,
         message: str,
         status_code: int = 500,
-        type: Optional[str] = "runtime_error",
-        param: Optional[str] = None,
-        code: Optional[str] = None,
-        display_message: Optional[str] = None,
+        type: str | None = "runtime_error",
+        param: str | None = None,
+        code: str | None = None,
+        display_message: str | None = None,
     ) -> None:
         self.message = message
         self.status_code = status_code

{aidial_client-0.11.0.dev1 → aidial_client-0.11.0.dev2}/aidial_client/_http_client/_async.py

@@ -1,16 +1,8 @@
 import asyncio
-from contextlib import asynccontextmanager
+from collections.abc import AsyncIterator, Callable, Mapping
+from contextlib import asynccontextmanager, suppress
 from http import HTTPStatus
-from typing import (
-    Any,
-    AsyncIterator,
-    Callable,
-    Dict,
-    Mapping,
-    Optional,
-    Type,
-    Union,
-)
+from typing import Any
 
 import httpx
 
@@ -30,7 +22,7 @@ class AsyncHTTPClient(BaseHTTPClient[httpx.AsyncClient, AsyncAuthValue]):
             timeout=self._timeout,
         )
 
-    async def auth_headers(self) -> Dict[str, str]:
+    async def auth_headers(self) -> dict[str, str]:
         return await aget_combined_auth_headers(
             api_key=self._api_key, bearer_token=self._bearer_token
         )
@@ -39,7 +31,7 @@ class AsyncHTTPClient(BaseHTTPClient[httpx.AsyncClient, AsyncAuthValue]):
         self,
         *,
         options: FinalRequestOptions,
-        cast_to: Type[ResponseT],
+        cast_to: type[ResponseT],
         remaining_retries: int,
     ) -> ResponseT:
         remaining = remaining_retries - 1
@@ -57,11 +49,10 @@ class AsyncHTTPClient(BaseHTTPClient[httpx.AsyncClient, AsyncAuthValue]):
         self,
         *,
         options: FinalRequestOptions,
-        cast_to: Type[ResponseT],
-        remaining_retries: Optional[int] = None,
-        on_http_error: Optional[
-            Callable[[httpx.HTTPStatusError], Optional[DialException]]
-        ] = None,
+        cast_to: type[ResponseT],
+        remaining_retries: int | None = None,
+        on_http_error: Callable[[httpx.HTTPStatusError], DialException | None]
+        | None = None,
     ) -> ResponseT:
         retries = self._remaining_retries(remaining_retries, options)
         auth_headers = await self.auth_headers()
@@ -127,8 +118,8 @@ class AsyncHTTPClient(BaseHTTPClient[httpx.AsyncClient, AsyncAuthValue]):
         method: str,
         url: str,
         json_data: Any,
-        headers: Optional[Mapping[str, str]] = None,
-        timeout: Union[float, httpx.Timeout, None, NotGiven] = NOT_GIVEN,
+        headers: Mapping[str, str] | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
     ) -> AsyncIterator[httpx.Response]:
         """Open an SSE streaming response. Yields the open httpx.Response.
 
@@ -155,10 +146,8 @@ class AsyncHTTPClient(BaseHTTPClient[httpx.AsyncClient, AsyncAuthValue]):
                 try:
                     response.raise_for_status()
                 except httpx.HTTPStatusError as err:
-                    try:
+                    with suppress(httpx.HTTPError):
                         await response.aread()
-                    except httpx.HTTPError:
-                        pass
                     raise self._make_dial_error_from_response(
                         err.response
                     ) from err

{aidial_client-0.11.0.dev1 → aidial_client-0.11.0.dev2}/aidial_client/_http_client/_base.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 from http import HTTPStatus
 from random import uniform
-from typing import Dict, Generic, Optional, TypeVar, Union
+from typing import Generic, TypeVar
 
 import httpx
 
@@ -13,23 +13,23 @@ from aidial_client._utils._type_guard import is_mapping
 from aidial_client.helpers._url import enforce_trailing_slash
 
 _HttpInternalClientT = TypeVar(
-    "_HttpInternalClientT", bound=Union[httpx.Client, httpx.AsyncClient]
+    "_HttpInternalClientT", bound=httpx.Client | httpx.AsyncClient
 )
 
 
 class BaseHTTPClient(ABC, Generic[_HttpInternalClientT, AuthValueT]):
     _internal_http_client: _HttpInternalClientT
-    _api_key: Optional[AuthValueT]
-    _bearer_token: Optional[AuthValueT]
+    _api_key: AuthValueT | None
+    _bearer_token: AuthValueT | None
 
     def __init__(
         self,
         base_url: str,
-        api_key: Optional[AuthValueT],
-        bearer_token: Optional[AuthValueT],
+        api_key: AuthValueT | None,
+        bearer_token: AuthValueT | None,
         max_retries: int,
-        timeout: Union[float, httpx.Timeout, None],
-        internal_http_client: Optional[_HttpInternalClientT] = None,
+        timeout: float | httpx.Timeout | None,
+        internal_http_client: _HttpInternalClientT | None = None,
     ):
         self.base_url = httpx.URL(enforce_trailing_slash(base_url))
         self._api_key = api_key
@@ -57,7 +57,7 @@ class BaseHTTPClient(ABC, Generic[_HttpInternalClientT, AuthValueT]):
     def _build_request(
         self,
         options: FinalRequestOptions,
-        auth_headers: Dict[str, str],
+        auth_headers: dict[str, str],
     ) -> httpx.Request:
         custom_headers = options.headers or {}
         return self._internal_http_client.build_request(
@@ -88,10 +88,7 @@ class BaseHTTPClient(ABC, Generic[_HttpInternalClientT, AuthValueT]):
         if response.status_code == HTTPStatus.CONFLICT:
             return True
 
-        if response.status_code == HTTPStatus.TOO_MANY_REQUESTS:
-            return True
-
-        return False
+        return response.status_code == HTTPStatus.TOO_MANY_REQUESTS
 
     def _calculate_retry_sleep_seconds(
         self,
@@ -106,7 +103,7 @@ class BaseHTTPClient(ABC, Generic[_HttpInternalClientT, AuthValueT]):
         sleep_seconds = min(
             INITIAL_RETRY_DELAY * pow(2.0, nb_retries), MAX_RETRY_DELAY
         )
-        timeout = sleep_seconds + uniform(-0.5, 0.5)
+        timeout = sleep_seconds + uniform(-0.5, 0.5)  # noqa: S311
         return max(0, timeout)
 
     def _make_dial_error_from_response(

{aidial_client-0.11.0.dev1 → aidial_client-0.11.0.dev2}/aidial_client/_http_client/_sse.py

@@ -1,4 +1,4 @@
-from typing import AsyncIterator, Iterator, List
+from collections.abc import AsyncIterator, Iterator
 
 from aidial_client._log import logger
 
@@ -9,20 +9,23 @@ _UNCOMMITTED_BUFFER_WARNING = (
 
 
 def _strip_field(line: str, prefix: str) -> str:
-    """Strip a single leading U+0020 SPACE after the field colon, per the SSE spec."""
+    """
+    Strip a single leading U+0020 SPACE after the field colon, per the SSE spec.
+    """
     value = line[len(prefix) :]
-    return value[1:] if value.startswith(" ") else value
+    return value.removeprefix(" ")
 
 
 def iter_data_events(lines: Iterator[str]) -> Iterator[str]:
-    """Yield the payload of each complete ``data:`` event from an SSE line stream.
+    """
+    Yield the payload of each complete ``data:`` event from an SSE line stream.
 
     An event is complete when a blank line follows the ``data:`` line(s). Per
     the SSE dispatch rule, a buffer that has not been terminated by a blank
     line is discarded (we do NOT flush partial events at end of stream).
     Comment lines (``:``) and other field names are ignored.
     """
-    buffer: List[str] = []
+    buffer: list[str] = []
     for line in lines:
         if line == "":
             if buffer:
@@ -35,7 +38,7 @@ def iter_data_events(lines: Iterator[str]) -> Iterator[str]:
 
 
 async def aiter_data_events(lines: AsyncIterator[str]) -> AsyncIterator[str]:
-    buffer: List[str] = []
+    buffer: list[str] = []
     async for line in lines:
         if line == "":
             if buffer:

{aidial_client-0.11.0.dev1 → aidial_client-0.11.0.dev2}/aidial_client/_http_client/_sync.py

@@ -1,7 +1,8 @@
 import time
-from contextlib import contextmanager
+from collections.abc import Callable, Iterator, Mapping
+from contextlib import contextmanager, suppress
 from http import HTTPStatus
-from typing import Any, Callable, Dict, Iterator, Mapping, Optional, Type, Union
+from typing import Any
 
 import httpx
 
@@ -22,7 +23,7 @@ class SyncHTTPClient(BaseHTTPClient[httpx.Client, SyncAuthValue]):
     def _retry_request(
         self,
         options: FinalRequestOptions,
-        cast_to: Type[ResponseT],
+        cast_to: type[ResponseT],
         remaining_retries: int,
     ) -> ResponseT:
         remaining = remaining_retries - 1
@@ -38,7 +39,7 @@ class SyncHTTPClient(BaseHTTPClient[httpx.Client, SyncAuthValue]):
             remaining_retries=remaining,
         )
 
-    def auth_headers(self) -> Dict[str, str]:
+    def auth_headers(self) -> dict[str, str]:
         return get_combined_auth_headers(
             api_key=self._api_key, bearer_token=self._bearer_token
         )
@@ -46,12 +47,11 @@ class SyncHTTPClient(BaseHTTPClient[httpx.Client, SyncAuthValue]):
     def request(
         self,
         *,
-        cast_to: Type[ResponseT],
+        cast_to: type[ResponseT],
         options: FinalRequestOptions,
-        remaining_retries: Optional[int] = None,
-        on_http_error: Optional[
-            Callable[[httpx.HTTPStatusError], Optional[DialException]]
-        ] = None,
+        remaining_retries: int | None = None,
+        on_http_error: Callable[[httpx.HTTPStatusError], DialException | None]
+        | None = None,
     ) -> ResponseT:
         retries = self._remaining_retries(remaining_retries, options)
         auth_headers = self.auth_headers()
@@ -118,8 +118,8 @@ class SyncHTTPClient(BaseHTTPClient[httpx.Client, SyncAuthValue]):
         method: str,
         url: str,
         json_data: Any,
-        headers: Optional[Mapping[str, str]] = None,
-        timeout: Union[float, httpx.Timeout, None, NotGiven] = NOT_GIVEN,
+        headers: Mapping[str, str] | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
     ) -> Iterator[httpx.Response]:
         """Open an SSE streaming response. Yields the open httpx.Response.
 
@@ -146,10 +146,8 @@ class SyncHTTPClient(BaseHTTPClient[httpx.Client, SyncAuthValue]):
                 try:
                     response.raise_for_status()
                 except httpx.HTTPStatusError as err:
-                    try:
+                    with suppress(httpx.HTTPError):
                         response.read()
-                    except httpx.HTTPError:
-                        pass
                     raise self._make_dial_error_from_response(
                         err.response
                     ) from err

{aidial_client-0.11.0.dev1 → aidial_client-0.11.0.dev2}/aidial_client/_internal_types/_generic.py

@@ -1,4 +1,4 @@
-from typing import TypeVar, Union
+from typing import TypeVar
 
 import httpx
 
@@ -10,15 +10,13 @@ from aidial_client.types.file import FileDownloadResponse
 
 ResponseT = TypeVar(
     "ResponseT",
-    bound=Union[
-        ExtraAllowModel,
-        ExtraForbidModel,
-        bytes,
-        str,
-        dict,
-        httpx.Response,
-        FileDownloadResponse,
-        None,
-    ],
+    bound=ExtraAllowModel
+    | ExtraForbidModel
+    | bytes
+    | str
+    | dict
+    | httpx.Response
+    | FileDownloadResponse
+    | None,
 )
 NoneType = type(None)

{aidial_client-0.11.0.dev1 → aidial_client-0.11.0.dev2}/aidial_client/_internal_types/_http_request.py

@@ -1,13 +1,9 @@
+from collections.abc import Mapping, Sequence
 from io import BufferedReader
 from typing import (
     IO,
     Any,
     Literal,
-    Mapping,
-    Optional,
-    Sequence,
-    Tuple,
-    Union,
     final,
 )
 
@@ -16,29 +12,29 @@ from httpx import Timeout
 from aidial_client._compatibility.pydantic_v1 import BaseModel
 from aidial_client._internal_types._defaults import NOT_GIVEN, NotGiven
 
-FileContent = Union[
-    IO[bytes],
-    bytes,
-    str,
-    # Somehow, pydantic doesn't recognize result of open('...', 'rb') as IO[bytes]
-    # even though BufferedReader is a subclass of IO[bytes]
-    BufferedReader,
-]
-FileTypes = Union[
+FileContent = (
+    IO[bytes]
+    | bytes
+    | str
+    # Somehow, pydantic doesn't recognize result of open('...', 'rb')
+    # as IO[bytes] even though BufferedReader is a subclass of IO[bytes]
+    | BufferedReader
+)
+FileTypes = (
     # file (or bytes)
-    FileContent,
+    FileContent
     # (filename, file (or bytes))
-    Tuple[Optional[str], FileContent],
+    | tuple[str | None, FileContent]
     # (filename, file (or bytes), content_type)
-    Tuple[Optional[str], FileContent, Optional[str]],
+    | tuple[str | None, FileContent, str | None]
     # (filename, file (or bytes), content_type, headers)
-    Tuple[Optional[str], FileContent, Optional[str], Mapping[str, str]],
-]
+    | tuple[str | None, FileContent, str | None, Mapping[str, str]]
+)
 
 Params = Mapping[str, Any]
 Headers = Mapping[str, Any]
 Data = Mapping[str, Any]
-RequestFiles = Union[Mapping[str, FileTypes], Sequence[Tuple[str, FileTypes]]]
+RequestFiles = Mapping[str, FileTypes] | Sequence[tuple[str, FileTypes]]
 
 
 @final
@@ -48,12 +44,12 @@ class FinalRequestOptions(BaseModel):
 
     method: Literal["GET", "PUT", "POST", "DELETE"]
     url: str
-    params: Optional[Params] = None
-    headers: Optional[Headers] = None
-    max_retries: Union[int, NotGiven] = NOT_GIVEN
-    timeout: Union[float, Timeout, NotGiven, None] = NOT_GIVEN
-    files: Optional[RequestFiles] = None
-    json_data: Optional[Data] = None
+    params: Params | None = None
+    headers: Headers | None = None
+    max_retries: int | NotGiven = NOT_GIVEN
+    timeout: float | Timeout | NotGiven | None = NOT_GIVEN
+    files: RequestFiles | None = None
+    json_data: Data | None = None
 
     def get_max_retries(self, max_retries: int) -> int:
         if isinstance(self.max_retries, NotGiven):
@@ -61,8 +57,8 @@ class FinalRequestOptions(BaseModel):
         return self.max_retries
 
     def get_timeout(
-        self, timeout: Union[float, Timeout, None]
-    ) -> Union[float, Timeout, None]:
+        self, timeout: float | Timeout | None
+    ) -> float | Timeout | None:
         if isinstance(self.timeout, NotGiven):
             return timeout
         return self.timeout