Custom timeout for requests

CHANGELOG.md

@@ -12,6 +12,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Added support for `XChainModifyBridge` flag maps (fixing an issue with `NFTokenCreateOffer` flag names)
 - Fixed `XChainModifyBridge` validation to allow just clearing of `MinAccountCreateAmount`
 - Currency codes with special characters not being allowed by IssuedCurrency objects.
+- Specify custom timeout parameter for requests.
 
 ## [2.5.0] - 2023-11-30
 

xrpl/asyncio/clients/async_websocket_client.py

@@ -3,7 +3,7 @@
 
 from collections.abc import AsyncIterator
 from types import TracebackType
-from typing import Any, Dict, Type
+from typing import Any, Dict, Optional, Type
 
 from xrpl.asyncio.clients.async_client import AsyncClient
 from xrpl.asyncio.clients.exceptions import XRPLWebsocketException
@@ -262,7 +262,9 @@ async def send(self: AsyncWebsocketClient, request: Request) -> None:
             raise XRPLWebsocketException("Websocket is not open")
         await self._do_send(request)
 
-    async def _request_impl(self: WebsocketBase, request: Request) -> Response:
+    async def _request_impl(
+        self: WebsocketBase, request: Request, timeout: Optional[float] = None
+    ) -> Response:
         """
         ``_request_impl`` implementation for async websocket.
 
@@ -280,4 +282,4 @@ async def _request_impl(self: WebsocketBase, request: Request) -> Response:
         """
         if not self.is_open():
             raise XRPLWebsocketException("Websocket is not open")
-        return await self._do_request_impl(request)
+        return await self._do_request_impl(request, timeout)

xrpl/asyncio/clients/client.py

@@ -4,9 +4,15 @@
 from abc import ABC, abstractmethod
 from typing import Optional
 
+from typing_extensions import Final
+
 from xrpl.models.requests.request import Request
 from xrpl.models.response import Response
 
+# The default request timeout duration. If you need more time, please pass the required
+# value into the Client._request_impl function
+_TIMEOUT: Final[float] = 10.0
+
 
 class Client(ABC):
     """
@@ -27,14 +33,22 @@ def __init__(self: Client, url: str) -> None:
         self.build_version: Optional[str] = None
 
     @abstractmethod
-    async def _request_impl(self: Client, request: Request) -> Response:
+    async def _request_impl(
+        self: Client, request: Request, timeout: Optional[float] = _TIMEOUT
+    ) -> Response:
         """
         This is the actual driver for a given Client's request. It must be
         async because all of the helper functions in this library are
         async-first. Implement this in a given Client.
 
         Arguments:
             request: An object representing information about a rippled request.
+            timeout: The maximum tolerable delay on waiting for a response.
+                Note: Optional is used in the type in order to honor the existing
+                behavior in certain overridden functions. WebsocketBase.do_request_impl
+                waits indefinitely for the completion of a request, whereas
+                JsonRpcBase._request_impl waits for 10 seconds before timing out a
+                request.
 
         Returns:
             The response from the server, as a Response object.

xrpl/asyncio/clients/json_rpc_base.py

@@ -2,18 +2,16 @@
 from __future__ import annotations
 
 from json import JSONDecodeError
+from typing import Optional
 
 from httpx import AsyncClient
-from typing_extensions import Final
 
-from xrpl.asyncio.clients.client import Client
+from xrpl.asyncio.clients.client import _TIMEOUT, Client
 from xrpl.asyncio.clients.exceptions import XRPLRequestFailureException
 from xrpl.asyncio.clients.utils import json_to_response, request_to_json_rpc
 from xrpl.models.requests.request import Request
 from xrpl.models.response import Response
 
-_TIMEOUT: Final[float] = 10.0
-
 
 class JsonRpcBase(Client):
     """
@@ -22,12 +20,16 @@ class JsonRpcBase(Client):
     :meta private:
     """
 
-    async def _request_impl(self: JsonRpcBase, request: Request) -> Response:
+    async def _request_impl(
+        self: JsonRpcBase, request: Request, timeout: Optional[float] = _TIMEOUT
+    ) -> Response:
         """
         Base ``_request_impl`` implementation for JSON RPC.
 
         Arguments:
             request: An object representing information about a rippled request.
+            timeout: The duration within which we expect to hear a response from the
+            rippled validator.
 
         Returns:
             The response from the server, as a Response object.
@@ -37,7 +39,7 @@ async def _request_impl(self: JsonRpcBase, request: Request) -> Response:
 
         :meta private:
         """
-        async with AsyncClient(timeout=_TIMEOUT) as http_client:
+        async with AsyncClient(timeout=timeout) as http_client:
             response = await http_client.post(
                 self.url,
                 json=request_to_json_rpc(request),

xrpl/asyncio/clients/websocket_base.py

@@ -199,7 +199,9 @@ async def _do_pop_message(self: WebsocketBase) -> Dict[str, Any]:
         cast(_MESSAGES_TYPE, self._messages).task_done()
         return msg
 
-    async def _do_request_impl(self: WebsocketBase, request: Request) -> Response:
+    async def _do_request_impl(
+        self: WebsocketBase, request: Request, timeout: Optional[float]
+    ) -> Response:
         """
         Base ``_request_impl`` implementation for websockets.
 
@@ -221,8 +223,14 @@ async def _do_request_impl(self: WebsocketBase, request: Request) -> Response:
 
         # fire-and-forget the send, and await the Future
         asyncio.create_task(self._do_send_no_future(request_with_id))
-        raw_response = await self._open_requests[request_str]
 
-        # remove the resolved Future, hopefully getting it garbage colleted
-        del self._open_requests[request_str]
+        try:
+            raw_response = await asyncio.wait_for(
+                self._open_requests[request_str], timeout
+            )
+        finally:
+            # remove the resolved Future, hopefully getting it garbage colleted
+            # Ensure the request is removed whether it times out or not
+            del self._open_requests[request_str]
+
         return websocket_to_response(raw_response)

xrpl/clients/websocket_client.py

@@ -200,7 +200,9 @@ def send(self: WebsocketClient, request: Request) -> None:
             self._do_send(request), cast(asyncio.AbstractEventLoop, self._loop)
         ).result()
 
-    async def _request_impl(self: WebsocketClient, request: Request) -> Response:
+    async def _request_impl(
+        self: WebsocketClient, request: Request, timeout: Optional[float] = None
+    ) -> Response:
         """
         ``_request_impl`` implementation for sync websockets that ensures the
         ``WebsocketBase._do_request_impl`` implementation is run on the other thread.
@@ -232,6 +234,6 @@ async def _request_impl(self: WebsocketClient, request: Request) -> Response:
         # completely block the main thread until completed,
         # just as if it were not async.
         return asyncio.run_coroutine_threadsafe(
-            self._do_request_impl(request),
+            self._do_request_impl(request, timeout),
             cast(asyncio.AbstractEventLoop, self._loop),
         ).result()