web3 7.11.1__py3-none-any.whl → 7.12.0__py3-none-any.whl

web3/providers/legacy_websocket.py

@@ -27,7 +27,6 @@ from websockets.legacy.client import (
 )
 
 from web3._utils.batching import (
-    batching_context,
     sort_batch_response_by_response_ids,
 )
 from web3._utils.caching import (
@@ -136,7 +135,7 @@ class LegacyWebSocketProvider(JSONBaseProvider):
     @handle_request_caching
     def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
         self.logger.debug(
-            f"Making request WebSocket. URI: {self.endpoint_uri}, " f"Method: {method}"
+            "Making request WebSocket. URI: %s, Method: %s", self.endpoint_uri, method
         )
         request_data = self.encode_rpc_request(method, params)
         future = asyncio.run_coroutine_threadsafe(
@@ -144,13 +143,13 @@ class LegacyWebSocketProvider(JSONBaseProvider):
         )
         return future.result()
 
-    @batching_context
     def make_batch_request(
         self, requests: List[Tuple[RPCEndpoint, Any]]
     ) -> List[RPCResponse]:
         self.logger.debug(
-            f"Making batch request WebSocket. URI: {self.endpoint_uri}, "
-            f"Methods: {requests}"
+            "Making batch request WebSocket. URI: %s, Methods: %s",
+            self.endpoint_uri,
+            requests,
         )
         request_data = self.encode_batch_rpc_request(requests)
         future = asyncio.run_coroutine_threadsafe(

web3/providers/persistent/persistent.py

@@ -24,7 +24,6 @@ from websockets import (
 
 from web3._utils.batching import (
     BATCH_REQUEST_ID,
-    async_batching_context,
     sort_batch_response_by_response_ids,
 )
 from web3._utils.caching import (
@@ -71,16 +70,16 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
 
     _send_func_cache: Tuple[
         Optional[int], Optional[Callable[..., Coroutine[Any, Any, RPCRequest]]]
-    ] = (
-        None,
-        None,
-    )
+    ] = (None, None)
     _recv_func_cache: Tuple[
         Optional[int], Optional[Callable[..., Coroutine[Any, Any, RPCResponse]]]
-    ] = (
-        None,
-        None,
-    )
+    ] = (None, None)
+    _send_batch_func_cache: Tuple[
+        Optional[int], Optional[Callable[..., Coroutine[Any, Any, List[RPCRequest]]]]
+    ] = (None, None)
+    _recv_batch_func_cache: Tuple[
+        Optional[int], Optional[Callable[..., Coroutine[Any, Any, List[RPCResponse]]]]
+    ] = (None, None)
 
     def __init__(
         self,
@@ -98,13 +97,14 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
             request_information_cache_size=request_information_cache_size,
         )
         self._message_listener_task: Optional["asyncio.Task[None]"] = None
-        self._batch_request_counter: Optional[int] = None
         self._listen_event: asyncio.Event = asyncio.Event()
         self._max_connection_retries = max_connection_retries
 
         self.request_timeout = request_timeout
         self.silence_listener_task_exceptions = silence_listener_task_exceptions
 
+    # -- cached middleware request/response functions -- #
+
     async def send_func(
         self, async_w3: "AsyncWeb3", middleware_onion: "MiddlewareOnion"
     ) -> Callable[..., Coroutine[Any, Any, RPCRequest]]:
@@ -155,6 +155,60 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
 
         return self._recv_func_cache[1]
 
+    async def send_batch_func(
+        self, async_w3: "AsyncWeb3", middleware_onion: "MiddlewareOnion"
+    ) -> Callable[..., Coroutine[Any, Any, List[RPCRequest]]]:
+        middleware = middleware_onion.as_tuple_of_middleware()
+        cache_key = hash(tuple(id(mw) for mw in middleware))
+
+        if cache_key != self._send_batch_func_cache[0]:
+
+            async def send_func(
+                requests: List[Tuple[RPCEndpoint, Any]]
+            ) -> List[RPCRequest]:
+                for mw in middleware:
+                    initialized = mw(async_w3)
+                    requests = [
+                        await initialized.async_request_processor(method, params)
+                        for (method, params) in requests
+                    ]
+                return await self.send_batch_request(requests)
+
+            self._send_batch_func_cache = (cache_key, send_func)
+
+        return self._send_batch_func_cache[1]
+
+    async def recv_batch_func(
+        self, async_w3: "AsyncWeb3", middleware_onion: "MiddlewareOnion"
+    ) -> Callable[..., Coroutine[Any, Any, List[RPCResponse]]]:
+        middleware = middleware_onion.as_tuple_of_middleware()
+        cache_key = hash(tuple(id(mw) for mw in middleware))
+
+        if cache_key != self._recv_batch_func_cache[0]:
+
+            async def recv_function(
+                rpc_requests: List[RPCRequest],
+            ) -> List[RPCResponse]:
+                methods = [rpc_request["method"] for rpc_request in rpc_requests]
+                responses = await self.recv_for_batch_request(rpc_requests)
+                for mw in reversed(middleware):
+                    if not isinstance(responses, list):
+                        # RPC errors return only one response with the error object
+                        return responses
+
+                    initialized = mw(async_w3)
+                    responses = [
+                        await initialized.async_response_processor(m, r)
+                        for m, r in zip(methods, responses)
+                    ]
+                return responses
+
+            self._recv_batch_func_cache = (cache_key, recv_function)
+
+        return self._recv_batch_func_cache[1]
+
+    # -- connection management -- #
+
     def get_endpoint_uri_or_ipc_path(self) -> str:
         if hasattr(self, "endpoint_uri"):
             return str(self.endpoint_uri)
@@ -167,6 +221,7 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
             )
 
     async def connect(self) -> None:
+        endpoint = self.get_endpoint_uri_or_ipc_path()
         _connection_attempts = 0
         _backoff_rate_change = 1.75
         _backoff_time = 1.75
@@ -174,9 +229,7 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
         while _connection_attempts != self._max_connection_retries:
             try:
                 _connection_attempts += 1
-                self.logger.info(
-                    f"Connecting to: {self.get_endpoint_uri_or_ipc_path()}"
-                )
+                self.logger.info("Connecting to: %s", endpoint)
                 await self._provider_specific_connect()
                 self._message_listener_task = asyncio.create_task(
                     self._message_listener()
@@ -184,19 +237,18 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
                 self._message_listener_task.add_done_callback(
                     self._message_listener_callback
                 )
-                self.logger.info(
-                    f"Successfully connected to: {self.get_endpoint_uri_or_ipc_path()}"
-                )
+                self.logger.info("Successfully connected to: %s", endpoint)
                 break
             except (WebSocketException, OSError) as e:
                 if _connection_attempts == self._max_connection_retries:
                     raise ProviderConnectionError(
-                        f"Could not connect to: {self.get_endpoint_uri_or_ipc_path()}. "
+                        f"Could not connect to: {endpoint}. "
                         f"Retries exceeded max of {self._max_connection_retries}."
                     ) from e
                 self.logger.info(
-                    f"Could not connect to: {self.get_endpoint_uri_or_ipc_path()}. "
-                    f"Retrying in {round(_backoff_time, 1)} seconds.",
+                    "Could not connect to: %s. Retrying in %s seconds.",
+                    endpoint,
+                    round(_backoff_time, 1),
                     exc_info=True,
                 )
                 await asyncio.sleep(_backoff_time)
@@ -217,9 +269,12 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
         await self._provider_specific_disconnect()
         self._request_processor.clear_caches()
         self.logger.info(
-            f"Successfully disconnected from: {self.get_endpoint_uri_or_ipc_path()}"
+            "Successfully disconnected from: %s",
+            self.get_endpoint_uri_or_ipc_path(),
         )
 
+    # -- request methods -- #
+
     @async_handle_send_caching
     async def send_request(self, method: RPCEndpoint, params: Any) -> RPCRequest:
         request_dict = self.form_request(method, params)
@@ -238,20 +293,33 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
         rpc_request = await self.send_request(method, params)
         return await self.recv_for_request(rpc_request)
 
-    @async_batching_context
-    async def make_batch_request(
+    # -- batch requests -- #
+
+    async def send_batch_request(
         self, requests: List[Tuple[RPCEndpoint, Any]]
-    ) -> List[RPCResponse]:
-        request_data = self.encode_batch_rpc_request(requests)
+    ) -> List[RPCRequest]:
+        request_dicts = [
+            self.form_request(method, params) for (method, params) in requests
+        ]
+        request_data = self.encode_batch_request_dicts(request_dicts)
         await self.socket_send(request_data)
+        return request_dicts
 
-        # breakpoint()
+    async def recv_for_batch_request(
+        self, _request_dicts: List[RPCRequest]
+    ) -> List[RPCResponse]:
         response = cast(
             List[RPCResponse],
             await self._get_response_for_request_id(BATCH_REQUEST_ID),
         )
         return response
 
+    async def make_batch_request(
+        self, requests: List[Tuple[RPCEndpoint, Any]]
+    ) -> List[RPCResponse]:
+        request_dicts = await self.send_batch_request(requests)
+        return await self.recv_for_batch_request(request_dicts)
+
     # -- abstract methods -- #
 
     @abstractmethod
@@ -320,26 +388,26 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
         Check the request response cache for any errors not tied to current requests
         and raise them if found.
         """
-        if not self._is_batching:
-            for (
-                response
-            ) in self._request_processor._request_response_cache._data.values():
-                if isinstance(response, dict):
+        for response in self._request_processor._request_response_cache._data.values():
+            if isinstance(response, dict):
+                if "id" not in response:
+                    validate_rpc_response_and_raise_if_error(
+                        cast(RPCResponse, response), None, logger=self.logger
+                    )
+                else:
                     request = self._request_processor._request_information_cache.get_cache_entry(  # noqa: E501
                         generate_cache_key(response["id"])
                     )
                     if "error" in response and request is None:
-                        # if we find an error response in the cache without a
-                        # corresponding request, raise the error
                         validate_rpc_response_and_raise_if_error(
                             cast(RPCResponse, response), None, logger=self.logger
                         )
 
     async def _message_listener(self) -> None:
         self.logger.info(
-            f"{self.__class__.__qualname__} listener background task started. Storing "
-            "all messages in appropriate request processor queues / caches to be "
-            "processed."
+            "%s listener background task started. Storing all messages in "
+            "appropriate request processor queues / caches to be processed.",
+            self.__class__.__qualname__,
         )
         while True:
             # the use of sleep(0) seems to be the most efficient way to yield control
@@ -363,8 +431,8 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
                 self._raise_stray_errors_from_cache()
             except PersistentConnectionClosedOK as e:
                 self.logger.info(
-                    "Message listener background task has ended gracefully: "
-                    f"{e.user_message}"
+                    "Message listener background task has ended gracefully: %s",
+                    e.user_message,
                 )
                 # trigger a return to end the listener task and initiate the callback fn
                 return
@@ -382,8 +450,9 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
         """
         self.logger.error(
             "Exception caught in listener, error logging and keeping "
-            "listener background task alive."
-            f"\n    error={e.__class__.__name__}: {e}"
+            "listener background task alive.\n    error=%s: %s",
+            e.__class__.__name__,
+            e,
         )
 
     def _handle_listener_task_exceptions(self) -> None:
@@ -416,7 +485,8 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
 
                 if request_cache_key in self._request_processor._request_response_cache:
                     self.logger.debug(
-                        f"Popping response for id {request_id} from cache."
+                        "Popping response for id %s from cache.",
+                        request_id,
                     )
                     popped_response = await self._request_processor.pop_raw_response(
                         cache_key=request_cache_key,

web3/providers/persistent/request_processor.py

@@ -13,10 +13,6 @@ from typing import (
     Union,
 )
 
-from eth_utils.toolz import (
-    compose,
-)
-
 from web3._utils.batching import (
     BATCH_REQUEST_ID,
 )
@@ -128,7 +124,9 @@ class RequestProcessor:
             if cache_key in self._request_information_cache:
                 self._provider.logger.debug(
                     "This is a cached request, not caching request info because it is "
-                    f"not unique:\n    method={method},\n    params={params}"
+                    "not unique:\n    method=%s,\n    params=%s",
+                    method,
+                    params,
                 )
                 return None
 
@@ -137,9 +135,6 @@ class RequestProcessor:
                 raise Web3ValueError(
                     "Request id must be provided when not batching requests."
                 )
-            # the _batch_request_counter is set when entering the context manager
-            request_id = self._provider._batch_request_counter
-            self._provider._batch_request_counter += 1
 
         cache_key = generate_cache_key(request_id)
         request_info = RequestInformation(
@@ -148,8 +143,11 @@ class RequestProcessor:
             response_formatters,
         )
         self._provider.logger.debug(
-            f"Caching request info:\n    request_id={request_id},\n"
-            f"    cache_key={cache_key},\n    request_info={request_info.__dict__}"
+            "Caching request info:\n    request_id=%s,\n"
+            "    cache_key=%s,\n    request_info=%s",
+            request_id,
+            cache_key,
+            request_info.__dict__,
         )
         self._request_information_cache.cache(
             cache_key,
@@ -170,7 +168,9 @@ class RequestProcessor:
         if request_info is not None:
             self._provider.logger.debug(
                 "Request info popped from cache:\n"
-                f"    cache_key={cache_key},\n    request_info={request_info.__dict__}"
+                "    cache_key=%s,\n    request_info=%s",
+                cache_key,
+                request_info.__dict__,
             )
         return request_info
 
@@ -224,33 +224,6 @@ class RequestProcessor:
 
         return request_info
 
-    def append_result_formatter_for_request(
-        self, request_id: int, result_formatter: Callable[..., Any]
-    ) -> None:
-        cache_key = generate_cache_key(request_id)
-        cached_request_info_for_id: RequestInformation = (
-            self._request_information_cache.get_cache_entry(cache_key)
-        )
-        if cached_request_info_for_id is not None:
-            (
-                current_result_formatters,
-                error_formatters,
-                null_result_formatters,
-            ) = cached_request_info_for_id.response_formatters
-            cached_request_info_for_id.response_formatters = (
-                compose(
-                    result_formatter,
-                    current_result_formatters,
-                ),
-                error_formatters,
-                null_result_formatters,
-            )
-        else:
-            self._provider.logger.debug(
-                f"No cached request info for response id `{request_id}`. Cannot "
-                f"append response formatter for response."
-            )
-
     def append_middleware_response_processor(
         self,
         response: RPCResponse,
@@ -269,13 +242,16 @@ class RequestProcessor:
                 )
             else:
                 self._provider.logger.debug(
-                    f"No cached request info for response id `{response_id}`. Cannot "
-                    f"append middleware response processor for response: {response}"
+                    "No cached request info for response id `%s`. Cannot "
+                    "append middleware response processor for response: %s",
+                    response_id,
+                    response,
                 )
         else:
             self._provider.logger.debug(
                 "No response `id` in response. Cannot append middleware response "
-                f"processor for response: {response}"
+                "processor for response: %s",
+                response,
             )
 
     # raw response cache
@@ -302,7 +278,7 @@ class RequestProcessor:
                 await self._provider._listen_event.wait()
 
             self._provider.logger.debug(
-                f"Caching subscription response:\n    response={raw_response}"
+                "Caching subscription response:\n    response=%s", raw_response
             )
             subscription_id = raw_response.get("params", {}).get("subscription")
             sub_container = self._subscription_container
@@ -320,16 +296,20 @@ class RequestProcessor:
             # constant cache key for the batch response.
             cache_key = generate_cache_key(BATCH_REQUEST_ID)
             self._provider.logger.debug(
-                f"Caching batch response:\n    cache_key={cache_key},\n"
-                f"    response={raw_response}"
+                "Caching batch response:\n    cache_key=%s,\n    response=%s",
+                cache_key,
+                raw_response,
             )
             self._request_response_cache.cache(cache_key, raw_response)
         else:
             response_id = raw_response.get("id")
             cache_key = generate_cache_key(response_id)
             self._provider.logger.debug(
-                f"Caching response:\n    response_id={response_id},\n"
-                f"    cache_key={cache_key},\n    response={raw_response}"
+                "Caching response:\n    response_id=%s,\n"
+                "    cache_key=%s,\n    response=%s",
+                response_id,
+                cache_key,
+                raw_response,
             )
             self._request_response_cache.cache(cache_key, raw_response)
 
@@ -354,13 +334,15 @@ class RequestProcessor:
                 if self._subscription_queue_synced_with_ws_stream:
                     self._subscription_queue_synced_with_ws_stream = False
                 self._provider.logger.info(
-                    f"Subscription response queue has {qsize} subscriptions. "
-                    "Processing as FIFO."
+                    "Subscription response queue has %s subscriptions. "
+                    "Processing as FIFO.",
+                    qsize,
                 )
 
             self._provider.logger.debug(
                 "Subscription response popped from queue to be processed:\n"
-                f"    raw_response={raw_response}"
+                "    raw_response=%s",
+                raw_response,
             )
         else:
             if not cache_key:
@@ -372,8 +354,9 @@ class RequestProcessor:
             if raw_response is not None:
                 self._provider.logger.debug(
                     "Cached response popped from cache to be processed:\n"
-                    f"    cache_key={cache_key},\n"
-                    f"    raw_response={raw_response}"
+                    "    cache_key=%s,\n    raw_response=%s",
+                    cache_key,
+                    raw_response,
                 )
 
         return raw_response

web3/providers/persistent/subscription_manager.py

@@ -123,8 +123,9 @@ class SubscriptionManager:
             subscriptions._id = sub_id
             self._add_subscription(subscriptions)
             self.logger.info(
-                "Successfully subscribed to subscription:\n    "
-                f"label: {subscriptions.label}\n    id: {sub_id}"
+                "Successfully subscribed to subscription:\n    label: %s\n    id: %s",
+                subscriptions.label,
+                sub_id,
             )
             return sub_id
         elif isinstance(subscriptions, Sequence):
@@ -190,8 +191,10 @@ class SubscriptionManager:
             if await self._w3.eth._unsubscribe(subscriptions.id):
                 self._remove_subscription(subscriptions)
                 self.logger.info(
-                    "Successfully unsubscribed from subscription:\n    "
-                    f"label: {subscriptions.label}\n    id: {subscriptions.id}"
+                    "Successfully unsubscribed from subscription:\n"
+                    "    label: %s\n    id: %s",
+                    subscriptions.label,
+                    subscriptions.id,
                 )
 
                 if len(self._subscription_container.handler_subscriptions) == 0:
@@ -208,7 +211,7 @@ class SubscriptionManager:
             unsubscribed: List[bool] = []
             # re-create the subscription list to prevent modifying the original list
             # in case ``subscription_manager.subscriptions`` was passed in directly
-            subs = [sub for sub in subscriptions]
+            subs = list(subscriptions)
             for sub in subs:
                 if isinstance(sub, str):
                     sub = HexStr(sub)
@@ -216,7 +219,8 @@ class SubscriptionManager:
             return all(unsubscribed)
 
         self.logger.warning(
-            f"Failed to unsubscribe from subscription\n    subscription={subscriptions}"
+            "Failed to unsubscribe from subscription\n    subscription=%s",
+            subscriptions,
         )
         return False
 
@@ -240,7 +244,8 @@ class SubscriptionManager:
             if len(self.subscriptions) > 0:
                 self.logger.warning(
                     "Failed to unsubscribe from all subscriptions. Some subscriptions "
-                    f"are still active.\n    subscriptions={self.subscriptions}"
+                    "are still active.\n    subscriptions=%s",
+                    self.subscriptions,
                 )
             return False
 

web3/providers/rpc/async_rpc.py

@@ -36,7 +36,6 @@ from web3.types import (
 )
 
 from ..._utils.batching import (
-    async_batching_context,
     sort_batch_response_by_response_ids,
 )
 from ..._utils.caching import (
@@ -156,22 +155,23 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
     @async_handle_request_caching
     async def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
         self.logger.debug(
-            f"Making request HTTP. URI: {self.endpoint_uri}, Method: {method}"
+            "Making request HTTP. URI: %s, Method: %s", self.endpoint_uri, method
         )
         request_data = self.encode_rpc_request(method, params)
         raw_response = await self._make_request(method, request_data)
         response = self.decode_rpc_response(raw_response)
         self.logger.debug(
-            f"Getting response HTTP. URI: {self.endpoint_uri}, "
-            f"Method: {method}, Response: {response}"
+            "Getting response HTTP. URI: %s, Method: %s, Response: %s",
+            self.endpoint_uri,
+            method,
+            response,
         )
         return response
 
-    @async_batching_context
     async def make_batch_request(
         self, batch_requests: List[Tuple[RPCEndpoint, Any]]
     ) -> Union[List[RPCResponse], RPCResponse]:
-        self.logger.debug(f"Making batch request HTTP - uri: `{self.endpoint_uri}`")
+        self.logger.debug("Making batch request HTTP - uri: `%s`", self.endpoint_uri)
         request_data = self.encode_batch_rpc_request(batch_requests)
         raw_response = await self._request_session_manager.async_make_post_request(
             self.endpoint_uri, request_data, **self.get_request_kwargs()
@@ -191,4 +191,4 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
             await session.close()
         cache.clear()
 
-        self.logger.info(f"Successfully disconnected from: {self.endpoint_uri}")
+        self.logger.info("Successfully disconnected from: %s", self.endpoint_uri)

web3/providers/rpc/rpc.py

@@ -34,7 +34,6 @@ from web3.types import (
 )
 
 from ..._utils.batching import (
-    batching_context,
     sort_batch_response_by_response_ids,
 )
 from ..._utils.caching import (
@@ -164,22 +163,23 @@ class HTTPProvider(JSONBaseProvider):
     @handle_request_caching
     def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
         self.logger.debug(
-            f"Making request HTTP. URI: {self.endpoint_uri}, Method: {method}"
+            "Making request HTTP. URI: %s, Method: %s", self.endpoint_uri, method
         )
         request_data = self.encode_rpc_request(method, params)
         raw_response = self._make_request(method, request_data)
         response = self.decode_rpc_response(raw_response)
         self.logger.debug(
-            f"Getting response HTTP. URI: {self.endpoint_uri}, "
-            f"Method: {method}, Response: {response}"
+            "Getting response HTTP. URI: %s, Method: %s, Response: %s",
+            self.endpoint_uri,
+            method,
+            response,
         )
         return response
 
-    @batching_context
     def make_batch_request(
         self, batch_requests: List[Tuple[RPCEndpoint, Any]]
     ) -> Union[List[RPCResponse], RPCResponse]:
-        self.logger.debug(f"Making batch request HTTP, uri: `{self.endpoint_uri}`")
+        self.logger.debug("Making batch request HTTP, uri: `%s`", self.endpoint_uri)
         request_data = self.encode_batch_rpc_request(batch_requests)
         raw_response = self._request_session_manager.make_post_request(
             self.endpoint_uri, request_data, **self.get_request_kwargs()

web3/utils/subscriptions.py

@@ -87,10 +87,13 @@ def handler_wrapper(
         sub.handler_call_count += 1
         sub.manager.total_handler_calls += 1
         sub.manager.logger.debug(
-            f"Subscription handler called.\n"
-            f"    label: {sub.label}\n"
-            f"    call count: {sub.handler_call_count}\n"
-            f"    total handler calls: {sub.manager.total_handler_calls}"
+            "Subscription handler called.\n"
+            "    label: %s\n"
+            "    call count: %s\n"
+            "    total handler calls: %s",
+            sub.label,
+            sub.handler_call_count,
+            sub.manager.total_handler_calls,
         )
         await handler(context)