volcano-sdk-python 0.11.2__py3-none-any.whl → 0.11.3__py3-none-any.whl

volcano_sdk/_transport.py

@@ -9,11 +9,11 @@ from io import BytesIO
 from pathlib import PurePosixPath
 from typing import (
     TYPE_CHECKING,
-    Any,
     ParamSpec,
     Protocol,
     TypeVar,
     cast,
+    overload,
     runtime_checkable,
 )
 from uuid import UUID, uuid4
@@ -278,7 +278,7 @@ if TYPE_CHECKING:
     from ._generated.models.refresh_o_auth_provider_token_provider import (
         RefreshOAuthProviderTokenProvider,
     )
-    from .models import JSONValue
+    from .models import DurableExecutionStatus, JSONValue
 
 HTTP_CREATED = 201
 HTTP_UNAUTHORIZED = 401
@@ -305,6 +305,14 @@ ERROR_TYPES_BY_STATUS: dict[int, type[VolcanoError]] = {
 }
 
 
+@overload
+def _plain_json(value: Mapping[str, JSONValue]) -> dict[str, JSONValue]: ...
+
+
+@overload
+def _plain_json(value: JSONValue) -> JSONValue: ...
+
+
 def _plain_json(value: JSONValue) -> JSONValue:
     if isinstance(value, Mapping):
         return {key: _plain_json(item) for key, item in value.items()}
@@ -338,11 +346,21 @@ class _RawHTTPResponse(Protocol):
     def headers(self) -> Mapping[str, str]: ...
 
 
+class _ParsedHTTPResponse(_RawHTTPResponse, Protocol):
+    @property
+    def parsed(self) -> object: ...
+
+
+@runtime_checkable
+class _ModelPayload(Protocol):
+    def to_dict(self) -> Mapping[str, object]: ...
+
+
 @dataclass(frozen=True, slots=True)
 class DurableExecutionListRequest:
     """Filters and paging for a durable execution listing."""
 
-    status: str | None = None
+    status: DurableExecutionStatus | None = None
     page: int | None = None
     limit: int | None = None
 
@@ -618,7 +636,7 @@ class AuthCallOAuthAPITransport(Protocol):
         provider: CallOAuthProviderAPIProvider,
         endpoint: str,
         method: str,
-        body: Mapping[str, Any] | None,
+        body: Mapping[str, JSONValue] | None,
     ) -> TransportResponse: ...
 
 
@@ -652,7 +670,7 @@ class Transport(Protocol):
         *,
         authorization: str,
         database_name: str,
-        body: dict[str, Any],
+        body: dict[str, object],
     ) -> TransportResponse: ...
 
     def query_database_insert(
@@ -660,7 +678,7 @@ class Transport(Protocol):
         *,
         authorization: str,
         database_name: str,
-        body: dict[str, Any],
+        body: dict[str, object],
     ) -> TransportResponse: ...
 
     def query_database_update(
@@ -668,7 +686,7 @@ class Transport(Protocol):
         *,
         authorization: str,
         database_name: str,
-        body: dict[str, Any],
+        body: dict[str, object],
     ) -> TransportResponse: ...
 
     def query_database_delete(
@@ -676,7 +694,7 @@ class Transport(Protocol):
         *,
         authorization: str,
         database_name: str,
-        body: dict[str, Any],
+        body: dict[str, object],
     ) -> TransportResponse: ...
 
     def upload_storage_object(
@@ -727,7 +745,7 @@ class AsyncDatabaseSelectTransport(Protocol):
         *,
         authorization: str,
         database_name: str,
-        body: dict[str, Any],
+        body: dict[str, object],
     ) -> TransportResponse: ...
 
 
@@ -772,13 +790,91 @@ def _error_type(status: int) -> type[VolcanoError]:
     return VolcanoError
 
 
+class _InvalidGeneratedRequestError(TypeError):
+    def __init__(self, field: str) -> None:
+        super().__init__(f"Invalid generated request field: {field}")
+
+
+def _required_request_string(kwargs: Mapping[str, object], key: str) -> str:
+    value = kwargs.get(key)
+    if not isinstance(value, str):
+        raise _InvalidGeneratedRequestError(key)
+    return value
+
+
+def _request_headers(kwargs: Mapping[str, object]) -> dict[str, str]:
+    raw_headers = kwargs.get("headers", {})
+    if not isinstance(raw_headers, Mapping):
+        field = "headers"
+        raise _InvalidGeneratedRequestError(field)
+    source = cast("Mapping[object, object]", raw_headers)
+    headers: dict[str, str] = {}
+    for key, value in source.items():
+        if not isinstance(key, str) or not isinstance(value, str):
+            field = "headers"
+            raise _InvalidGeneratedRequestError(field)
+        headers[key] = value
+    return headers
+
+
+def _request_params(
+    kwargs: Mapping[str, object],
+) -> dict[str, str | int | float | bool | None] | None:
+    raw_params = kwargs.get("params")
+    if raw_params is None:
+        return None
+    if not isinstance(raw_params, Mapping):
+        field = "params"
+        raise _InvalidGeneratedRequestError(field)
+    source = cast("Mapping[object, object]", raw_params)
+    params: dict[str, str | int | float | bool | None] = {}
+    for key, value in source.items():
+        if not isinstance(key, str) or (
+            value is not None and not isinstance(value, (str, int, float, bool))
+        ):
+            field = "params"
+            raise _InvalidGeneratedRequestError(field)
+        params[key] = value
+    return params
+
+
+def _generated_request(
+    client: AuthenticatedClient, kwargs: Mapping[str, object]
+) -> httpx.Response:
+    if kwargs.keys() - {"method", "url", "headers", "json", "params"}:
+        field = "unsupported field"
+        raise _InvalidGeneratedRequestError(field)
+    return client.get_httpx_client().request(
+        method=_required_request_string(kwargs, "method"),
+        url=_required_request_string(kwargs, "url"),
+        headers=_request_headers(kwargs),
+        params=_request_params(kwargs),
+        json=kwargs.get("json"),
+    )
+
+
+def _json_object(response: httpx.Response) -> dict[str, object]:
+    raw = cast("object", response.json())
+    if not isinstance(raw, dict):
+        field = "response body"
+        raise _InvalidGeneratedRequestError(field)
+    source = cast("Mapping[object, object]", raw)
+    payload: dict[str, object] = {}
+    for key, value in source.items():
+        if not isinstance(key, str):
+            field = "response body key"
+            raise _InvalidGeneratedRequestError(field)
+        payload[key] = value
+    return payload
+
+
 def response_payload(response: TransportResponse, expected_status: int) -> object:
     status = int(response.status_code)
     if status != expected_status:
-        payload: Mapping[str, object]
+        payload: Mapping[object, object]
         raw_payload = response.payload
         if isinstance(raw_payload, dict):
-            payload = cast("Mapping[str, object]", raw_payload)
+            payload = cast("Mapping[object, object]", raw_payload)
         else:
             payload = {}
         message = str(
@@ -812,12 +908,12 @@ class GeneratedTransport:
         timeout: float = 60.0,
         httpx_transport: httpx.BaseTransport | None = None,
     ) -> None:
-        self._api_url = api_url.rstrip("/")
-        self._timeout = timeout
-        self._httpx_transport = httpx_transport
+        self._api_url: str = api_url.rstrip("/")
+        self._timeout: float = timeout
+        self._httpx_transport: httpx.BaseTransport | None = httpx_transport
 
     def _client(self, authorization: str) -> AuthenticatedClient:
-        httpx_args: dict[str, Any] = {}
+        httpx_args: dict[str, object] = {}
         if self._httpx_transport is not None:
             httpx_args["transport"] = self._httpx_transport
         return AuthenticatedClient(
@@ -828,15 +924,16 @@ class GeneratedTransport:
         )
 
     @staticmethod
-    def _response(response: Any) -> TransportResponse:
+    def _response(response: _ParsedHTTPResponse) -> TransportResponse:
         parsed = response.parsed
-        if hasattr(parsed, "to_dict"):
-            payload = parsed.to_dict()
+        if isinstance(parsed, _ModelPayload):
+            payload: object = parsed.to_dict()
         elif parsed is not None:
             payload = parsed
         else:
             try:
-                payload = json.loads(response.content)
+                raw = cast("object", json.loads(response.content))
+                payload = raw
             except (json.JSONDecodeError, UnicodeDecodeError):
                 payload = None
         return _GeneratedTransportResponse(
@@ -849,7 +946,7 @@ class GeneratedTransport:
     @staticmethod
     def _raw_response(response: _RawHTTPResponse) -> TransportResponse:
         try:
-            payload = json.loads(response.content)
+            payload = cast("object", json.loads(response.content))
         except (json.JSONDecodeError, UnicodeDecodeError):
             payload = None
         return _GeneratedTransportResponse(
@@ -900,9 +997,7 @@ class GeneratedTransport:
             user_metadata=AuthSignupAnonymousBodyUserMetadata.from_dict(metadata)
         )
         with self._client(authorization) as client:
-            response = client.get_httpx_client().request(
-                **signup_anonymous_kwargs(body=body)
-            )
+            response = _generated_request(client, signup_anonymous_kwargs(body=body))
         return self._raw_response(response)
 
     def auth_convert_anonymous(
@@ -920,8 +1015,8 @@ class GeneratedTransport:
         )
         try:
             with self._client(authorization) as client:
-                raw_response = client.get_httpx_client().request(
-                    **auth_convert_anonymous_kwargs(body=body)
+                raw_response = _generated_request(
+                    client, auth_convert_anonymous_kwargs(body=body)
                 )
                 if raw_response.status_code == HTTP_UNAUTHORIZED:
                     return self._raw_response(raw_response)
@@ -952,8 +1047,8 @@ class GeneratedTransport:
         email: str,
     ) -> TransportResponse:
         with self._client(authorization) as client:
-            response = client.get_httpx_client().request(
-                **forgot_password_kwargs(body=AuthForgotPasswordBody(email=email))
+            response = _generated_request(
+                client, forgot_password_kwargs(body=AuthForgotPasswordBody(email=email))
             )
         return self._raw_response(response)
 
@@ -964,8 +1059,8 @@ class GeneratedTransport:
         token: str,
     ) -> TransportResponse:
         with self._client(authorization) as client:
-            response = client.get_httpx_client().request(
-                **confirm_email_kwargs(body=AuthConfirmEmailBody(token=token))
+            response = _generated_request(
+                client, confirm_email_kwargs(body=AuthConfirmEmailBody(token=token))
             )
         return self._raw_response(response)
 
@@ -978,9 +1073,7 @@ class GeneratedTransport:
     ) -> TransportResponse:
         body = AuthResetPasswordBody(token=token, new_password=new_password)
         with self._client(authorization) as client:
-            response = client.get_httpx_client().request(
-                **reset_password_kwargs(body=body)
-            )
+            response = _generated_request(client, reset_password_kwargs(body=body))
         return self._raw_response(response)
 
     def auth_resend_confirmation(
@@ -991,9 +1084,7 @@ class GeneratedTransport:
     ) -> TransportResponse:
         body = AuthResendConfirmationBody(email=email)
         with self._client(authorization) as client:
-            response = client.get_httpx_client().request(
-                **resend_confirmation_kwargs(body=body)
-            )
+            response = _generated_request(client, resend_confirmation_kwargs(body=body))
         return self._raw_response(response)
 
     def auth_request_email_change(
@@ -1004,14 +1095,14 @@ class GeneratedTransport:
     ) -> TransportResponse:
         body = AuthRequestEmailChangeBody(new_email=new_email)
         with self._client(authorization) as client:
-            response = client.get_httpx_client().request(
-                **request_email_change_kwargs(body=body)
+            response = _generated_request(
+                client, request_email_change_kwargs(body=body)
             )
         return self._raw_response(response)
 
     def auth_cancel_email_change(self, *, authorization: str) -> TransportResponse:
         with self._client(authorization) as client:
-            response = client.get_httpx_client().request(**cancel_email_change_kwargs())
+            response = _generated_request(client, cancel_email_change_kwargs())
         return self._raw_response(response)
 
     def auth_confirm_email_change(
@@ -1023,8 +1114,8 @@ class GeneratedTransport:
         body = AuthConfirmEmailChangeBody(email_change_token=token)
         try:
             with self._client(authorization) as client:
-                raw_response = client.get_httpx_client().request(
-                    **auth_confirm_email_change_kwargs(body=body)
+                raw_response = _generated_request(
+                    client, auth_confirm_email_change_kwargs(body=body)
                 )
                 if raw_response.status_code == HTTP_UNAUTHORIZED:
                     return self._raw_response(raw_response)
@@ -1054,9 +1145,7 @@ class GeneratedTransport:
         authorization: str,
     ) -> TransportResponse:
         with self._client(authorization) as client:
-            response = client.get_httpx_client().request(
-                **delete_all_my_sessions_kwargs()
-            )
+            response = _generated_request(client, delete_all_my_sessions_kwargs())
         return self._raw_response(response)
 
     def auth_delete_my_session(
@@ -1066,8 +1155,8 @@ class GeneratedTransport:
         session_id: str,
     ) -> TransportResponse:
         with self._client(authorization) as client:
-            response = client.get_httpx_client().request(
-                **delete_my_session_kwargs(session_id=cast("UUID", session_id))
+            response = _generated_request(
+                client, delete_my_session_kwargs(session_id=cast("UUID", session_id))
             )
         return self._raw_response(response)
 
@@ -1079,13 +1168,13 @@ class GeneratedTransport:
         limit: int,
     ) -> TransportResponse:
         with self._client(authorization) as client:
-            response = client.get_httpx_client().request(
-                **get_my_sessions_kwargs(page=page, limit=limit)
+            response = _generated_request(
+                client, get_my_sessions_kwargs(page=page, limit=limit)
             )
         if response.status_code != HTTP_OK:
             return self._raw_response(response)
         try:
-            payload = AuthGetMySessionsResponse200.from_dict(response.json())
+            payload = AuthGetMySessionsResponse200.from_dict(_json_object(response))
         except (
             AttributeError,
             KeyError,
@@ -1107,13 +1196,13 @@ class GeneratedTransport:
         authorization: str,
     ) -> TransportResponse:
         with self._client(authorization) as client:
-            response = client.get_httpx_client().request(
-                **list_oauth_providers_kwargs()
-            )
+            response = _generated_request(client, list_oauth_providers_kwargs())
         if response.status_code != HTTP_OK:
             return self._raw_response(response)
         try:
-            payload = AuthListOAuthProvidersResponse200.from_dict(response.json())
+            payload = AuthListOAuthProvidersResponse200.from_dict(
+                _json_object(response)
+            )
         except (
             AttributeError,
             KeyError,
@@ -1172,13 +1261,11 @@ class GeneratedTransport:
         provider: AuthLinkOAuthProviderProvider,
     ) -> TransportResponse:
         with self._client(authorization) as client:
-            response = client.get_httpx_client().request(
-                **link_oauth_provider_kwargs(provider)
-            )
+            response = _generated_request(client, link_oauth_provider_kwargs(provider))
         if response.status_code != HTTP_OK:
             return self._raw_response(response)
         try:
-            payload = AuthLinkOAuthProviderResponse200.from_dict(response.json())
+            payload = AuthLinkOAuthProviderResponse200.from_dict(_json_object(response))
         except (
             AttributeError,
             KeyError,
@@ -1201,8 +1288,8 @@ class GeneratedTransport:
         provider: AuthUnlinkOAuthProviderProvider,
     ) -> TransportResponse:
         with self._client(authorization) as client:
-            response = client.get_httpx_client().request(
-                **unlink_oauth_provider_kwargs(provider)
+            response = _generated_request(
+                client, unlink_oauth_provider_kwargs(provider)
             )
         return self._raw_response(response)
 
@@ -1213,13 +1300,13 @@ class GeneratedTransport:
         provider: GetOAuthProviderTokenProvider,
     ) -> TransportResponse:
         with self._client(authorization) as client:
-            response = client.get_httpx_client().request(
-                **get_oauth_provider_token_kwargs(provider)
+            response = _generated_request(
+                client, get_oauth_provider_token_kwargs(provider)
             )
         if response.status_code != HTTP_OK:
             return self._raw_response(response)
         try:
-            payload = GetOAuthProviderTokenResponse200.from_dict(response.json())
+            payload = GetOAuthProviderTokenResponse200.from_dict(_json_object(response))
         except (
             AttributeError,
             KeyError,
@@ -1242,13 +1329,15 @@ class GeneratedTransport:
         provider: RefreshOAuthProviderTokenProvider,
     ) -> TransportResponse:
         with self._client(authorization) as client:
-            response = client.get_httpx_client().request(
-                **refresh_oauth_provider_token_kwargs(provider)
+            response = _generated_request(
+                client, refresh_oauth_provider_token_kwargs(provider)
             )
         if response.status_code != HTTP_OK:
             return self._raw_response(response)
         try:
-            payload = RefreshOAuthProviderTokenResponse200.from_dict(response.json())
+            payload = RefreshOAuthProviderTokenResponse200.from_dict(
+                _json_object(response)
+            )
         except (
             AttributeError,
             KeyError,
@@ -1271,20 +1360,20 @@ class GeneratedTransport:
         provider: CallOAuthProviderAPIProvider,
         endpoint: str,
         method: str,
-        body: Mapping[str, Any] | None,
+        body: Mapping[str, JSONValue] | None,
     ) -> TransportResponse:
-        request_values: dict[str, Any] = {"endpoint": endpoint, "method": method}
+        request_values: dict[str, object] = {"endpoint": endpoint, "method": method}
         if body is not None:
             request_values["body"] = _plain_json(body)
         request_body = CallOAuthProviderAPIBody.from_dict(request_values)
         with self._client(authorization) as client:
-            response = client.get_httpx_client().request(
-                **call_oauth_provider_api_kwargs(provider, body=request_body)
+            response = _generated_request(
+                client, call_oauth_provider_api_kwargs(provider, body=request_body)
             )
         if response.status_code != HTTP_OK:
             return self._raw_response(response)
         try:
-            payload = CallOAuthProviderAPIResponse200.from_dict(response.json())
+            payload = CallOAuthProviderAPIResponse200.from_dict(_json_object(response))
         except (
             AttributeError,
             KeyError,
@@ -1303,9 +1392,7 @@ class GeneratedTransport:
     def auth_get_user(self, *, authorization: str) -> TransportResponse:
         try:
             with self._client(authorization) as client:
-                raw_response = client.get_httpx_client().request(
-                    **auth_get_user_kwargs()
-                )
+                raw_response = _generated_request(client, auth_get_user_kwargs())
                 if raw_response.status_code == HTTP_UNAUTHORIZED:
                     return self._raw_response(raw_response)
                 response = build_auth_get_user_response(
@@ -1345,8 +1432,8 @@ class GeneratedTransport:
         )
         try:
             with self._client(authorization) as client:
-                raw_response = client.get_httpx_client().request(
-                    **auth_update_user_kwargs(body=body)
+                raw_response = _generated_request(
+                    client, auth_update_user_kwargs(body=body)
                 )
                 if raw_response.status_code == HTTP_UNAUTHORIZED:
                     return self._raw_response(raw_response)
@@ -1401,14 +1488,15 @@ class GeneratedTransport:
         *,
         authorization: str,
         database_name: str,
-        body: dict[str, Any],
+        body: dict[str, object],
     ) -> TransportResponse:
         with self._client(authorization) as client:
-            response = client.get_httpx_client().request(
-                **database_select_kwargs(
+            response = _generated_request(
+                client,
+                database_select_kwargs(
                     database_name,
                     body=DatabaseSelectRequest.from_dict(body),
-                )
+                ),
             )
             if response.status_code == HTTP_UNAUTHORIZED:
                 return self._raw_response(response)
@@ -1420,7 +1508,7 @@ class GeneratedTransport:
         *,
         authorization: str,
         database_name: str,
-        body: dict[str, Any],
+        body: dict[str, object],
     ) -> TransportResponse:
         async with self._client(authorization) as client:
             response = await query_database_select.asyncio_detailed(
@@ -1435,13 +1523,14 @@ class GeneratedTransport:
         *,
         authorization: str,
         database_name: str,
-        body: dict[str, Any],
+        body: dict[str, object],
     ) -> TransportResponse:
         with self._client(authorization) as client:
-            response = client.get_httpx_client().request(
-                **database_insert_kwargs(
+            response = _generated_request(
+                client,
+                database_insert_kwargs(
                     database_name, body=DatabaseInsertRequest.from_dict(body)
-                )
+                ),
             )
             if response.status_code == HTTP_UNAUTHORIZED:
                 return self._raw_response(response)
@@ -1453,13 +1542,14 @@ class GeneratedTransport:
         *,
         authorization: str,
         database_name: str,
-        body: dict[str, Any],
+        body: dict[str, object],
     ) -> TransportResponse:
         with self._client(authorization) as client:
-            response = client.get_httpx_client().request(
-                **database_update_kwargs(
+            response = _generated_request(
+                client,
+                database_update_kwargs(
                     database_name, body=DatabaseUpdateRequest.from_dict(body)
-                )
+                ),
             )
             if response.status_code == HTTP_UNAUTHORIZED:
                 return self._raw_response(response)
@@ -1471,13 +1561,14 @@ class GeneratedTransport:
         *,
         authorization: str,
         database_name: str,
-        body: dict[str, Any],
+        body: dict[str, object],
     ) -> TransportResponse:
         with self._client(authorization) as client:
-            response = client.get_httpx_client().request(
-                **database_delete_kwargs(
+            response = _generated_request(
+                client,
+                database_delete_kwargs(
                     database_name, body=DatabaseDeleteRequest.from_dict(body)
-                )
+                ),
             )
             if response.status_code == HTTP_UNAUTHORIZED:
                 return self._raw_response(response)
@@ -1706,9 +1797,7 @@ class GeneratedTransport:
         name: str,
     ) -> TransportResponse:
         with self._client(authorization) as client:
-            response = client.get_httpx_client().request(
-                **resolve_function_kwargs(name=name)
-            )
+            response = _generated_request(client, resolve_function_kwargs(name=name))
         return self._raw_response(response)
 
     def invoke_function(
@@ -1718,16 +1807,17 @@ class GeneratedTransport:
         function_id: str,
         payload: Mapping[str, JSONValue],
     ) -> TransportResponse:
-        plain_payload = cast("dict[str, JSONValue]", _plain_json(payload))
+        plain_payload = _plain_json(payload)
         body = FunctionInvocationRequest(
             payload=FunctionInvocationRequestPayload.from_dict(plain_payload)
         )
         with self._client(authorization) as client:
-            response = client.get_httpx_client().request(
-                **invoke_function_kwargs(
+            response = _generated_request(
+                client,
+                invoke_function_kwargs(
                     UUID(function_id),
                     body=body,
-                )
+                ),
             )
         return self._raw_response(response)
 
@@ -1741,7 +1831,7 @@ class GeneratedTransport:
         # The resolved endpoint is absolute and off the API host, so it cannot
         # go through the generated client's base URL. The body still uses the
         # invoke contract's { payload } envelope.
-        plain_payload = cast("dict[str, JSONValue]", _plain_json(payload))
+        plain_payload = _plain_json(payload)
         with self._client(authorization) as client:
             response = client.get_httpx_client().request(
                 method="POST",
@@ -1772,13 +1862,13 @@ class GeneratedTransport:
         project_id: str,
         request: Mapping[str, JSONValue],
     ) -> TransportResponse:
-        plain_request = cast("dict[str, Any]", _plain_json(request))
+        plain_request = _plain_json(request)
         with self._client(authorization) as client:
             request_kwargs = log_search_kwargs(
                 UUID(project_id), body=LogSearchRequest.from_dict(plain_request)
             )
             request_kwargs["json"] = plain_request
-            raw_response = client.get_httpx_client().request(**request_kwargs)
+            raw_response = _generated_request(client, request_kwargs)
             if raw_response.status_code == HTTP_UNAUTHORIZED:
                 return self._raw_response(raw_response)
             self._validate_log_response(raw_response, search_metadata)
@@ -1795,13 +1885,13 @@ class GeneratedTransport:
         project_id: str,
         request: Mapping[str, JSONValue],
     ) -> TransportResponse:
-        plain_request = cast("dict[str, Any]", _plain_json(request))
+        plain_request = _plain_json(request)
         with self._client(authorization) as client:
             request_kwargs = log_activity_kwargs(
                 UUID(project_id), body=LogActivityRequest.from_dict(plain_request)
             )
             request_kwargs["json"] = plain_request
-            raw_response = client.get_httpx_client().request(**request_kwargs)
+            raw_response = _generated_request(client, request_kwargs)
             if raw_response.status_code == HTTP_UNAUTHORIZED:
                 return self._raw_response(raw_response)
             self._validate_log_response(raw_response, activity_total)
@@ -1827,7 +1917,7 @@ class GeneratedTransport:
                 x_volcano_lock_token=cast("UUID", token),
                 x_volcano_request_id=cast("UUID", request_id or str(uuid4())),
             )
-            raw_response = client.get_httpx_client().request(**request_kwargs)
+            raw_response = _generated_request(client, request_kwargs)
             if raw_response.status_code != HTTP_CREATED:
                 return self._raw_response(raw_response)
             response = build_lock_acquire_response(client=client, response=raw_response)
@@ -1948,9 +2038,7 @@ class GeneratedTransport:
                 UUID(project_id),
                 function_id,
                 client=client,
-                status=(
-                    UNSET if request.status is None else cast("Any", request.status)
-                ),
+                status=UNSET if request.status is None else request.status,
                 page=UNSET if request.page is None else request.page,
                 limit=UNSET if request.limit is None else request.limit,
             )