web3 7.0.0b7__py3-none-any.whl → 7.0.0b8__py3-none-any.whl

web3/_utils/method_formatters.py

@@ -187,10 +187,28 @@ def apply_list_to_array_formatter(formatter: Any) -> Callable[..., Any]:
     return to_list(apply_formatter_to_array(formatter))
 
 
+def storage_key_to_hexstr(value: Union[bytes, int, str]) -> HexStr:
+    if not isinstance(value, (bytes, int, str)):
+        raise Web3ValueError(
+            f"Storage key must be one of bytes, int, str, got {type(value)}"
+        )
+    if isinstance(value, str):
+        if value.startswith("0x") and len(value) == 66:
+            return HexStr(value)
+        elif len(value) == 64:
+            return HexStr(f"0x{value}")
+    elif isinstance(value, bytes):
+        if len(value) == 32:
+            return HexBytes(value).to_0x_hex()
+    elif isinstance(value, int):
+        return storage_key_to_hexstr(hex(value))
+    raise Web3ValueError(f"Storage key must be a 32-byte value, got {value!r}")
+
+
 ACCESS_LIST_FORMATTER = type_aware_apply_formatters_to_dict(
     {
         "address": to_checksum_address,
-        "storageKeys": apply_list_to_array_formatter(to_hexbytes(64)),
+        "storageKeys": apply_list_to_array_formatter(storage_key_to_hexstr),
     }
 )
 

web3/_utils/module_testing/eth_module.py

@@ -1210,7 +1210,7 @@ class AsyncEthModuleTest:
         assert len(access_list) > 0
         assert access_list[0]["address"] is not None
         assert is_checksum_address(access_list[0]["address"])
-        assert len(access_list[0]["storageKeys"][0]) == 32
+        assert len(access_list[0]["storageKeys"][0]) == 66
         assert int(response["gasUsed"]) >= 0
 
         # assert the result can be used directly in a transaction dict
@@ -2786,7 +2786,7 @@ class EthModuleTest:
         assert len(access_list) > 0
         assert access_list[0]["address"] is not None
         assert is_checksum_address(access_list[0]["address"])
-        assert len(access_list[0]["storageKeys"][0]) == 32
+        assert len(access_list[0]["storageKeys"][0]) == 66
         assert int(response["gasUsed"]) >= 0
 
         # assert the result can be used directly in a transaction dict

web3/_utils/module_testing/module_testing_utils.py

@@ -1,6 +1,4 @@
-from collections import (
-    deque,
-)
+import asyncio
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -179,7 +177,9 @@ class WebSocketMessageStreamMock:
     def __init__(
         self, messages: Collection[bytes] = None, raise_exception: Exception = None
     ) -> None:
-        self.messages = deque(messages) if messages else deque()
+        self.queue = asyncio.Queue()  # type: ignore  # py38 issue
+        for msg in messages or []:
+            self.queue.put_nowait(msg)
         self.raise_exception = raise_exception
 
     def __await__(self) -> Generator[Any, Any, "Self"]:
@@ -192,13 +192,12 @@ class WebSocketMessageStreamMock:
         return self
 
     async def __anext__(self) -> bytes:
+        return await self.queue.get()
+
+    async def recv(self) -> bytes:
         if self.raise_exception:
             raise self.raise_exception
-
-        elif len(self.messages) == 0:
-            raise StopAsyncIteration
-
-        return self.messages.popleft()
+        return await self.queue.get()
 
     @staticmethod
     async def pong() -> Literal[False]:

web3/_utils/module_testing/persistent_connection_provider.py

@@ -23,6 +23,7 @@ from web3.middleware import (
 )
 from web3.types import (
     FormattedEthSubscriptionResponse,
+    RPCEndpoint,
 )
 
 if TYPE_CHECKING:
@@ -31,6 +32,22 @@ if TYPE_CHECKING:
     )
 
 
+SOME_BLOCK_KEYS = [
+    "number",
+    "hash",
+    "parentHash",
+    "transactionsRoot",
+    "stateRoot",
+    "receiptsRoot",
+    "size",
+    "gasLimit",
+    "gasUsed",
+    "timestamp",
+    "transactions",
+    "baseFeePerGas",
+]
+
+
 class PersistentConnectionProviderTest:
     @pytest.mark.asyncio
     @pytest.mark.parametrize(
@@ -372,22 +389,8 @@ class PersistentConnectionProviderTest:
         assert isinstance(pending, AttributeDict)
 
         # assert block values
-        some_block_keys = [
-            "number",
-            "hash",
-            "parentHash",
-            "transactionsRoot",
-            "stateRoot",
-            "receiptsRoot",
-            "size",
-            "gasLimit",
-            "gasUsed",
-            "timestamp",
-            "transactions",
-            "baseFeePerGas",
-        ]
-        assert all(k in latest.keys() for k in some_block_keys)
-        assert all(k in pending.keys() for k in some_block_keys)
+        assert all(k in latest.keys() for k in SOME_BLOCK_KEYS)
+        assert all(k in pending.keys() for k in SOME_BLOCK_KEYS)
 
         assert isinstance(block_num, int)
         assert latest["number"] == block_num
@@ -395,3 +398,28 @@ class PersistentConnectionProviderTest:
         assert isinstance(chain_id, int)
         assert isinstance(chain_id2, int)
         assert isinstance(chain_id3, int)
+
+    @pytest.mark.asyncio
+    async def test_public_socket_api(self, async_w3: "AsyncWeb3") -> None:
+        # send a request over the socket
+        await async_w3.socket.send(
+            RPCEndpoint("eth_getBlockByNumber"), ["latest", True]
+        )
+
+        # recv and validate the unprocessed response
+        response = await async_w3.socket.recv()
+        assert "id" in response, "Expected 'id' key in response."
+        assert "jsonrpc" in response, "Expected 'jsonrpc' key in response."
+        assert "result" in response, "Expected 'result' key in response."
+        assert all(k in response["result"].keys() for k in SOME_BLOCK_KEYS)
+        assert not isinstance(response["result"]["number"], int)  # assert not processed
+
+        # make a request over the socket
+        response = await async_w3.socket.make_request(
+            RPCEndpoint("eth_getBlockByNumber"), ["latest", True]
+        )
+        assert "id" in response, "Expected 'id' key in response."
+        assert "jsonrpc" in response, "Expected 'jsonrpc' key in response."
+        assert "result" in response, "Expected 'result' key in response."
+        assert all(k in response["result"].keys() for k in SOME_BLOCK_KEYS)
+        assert not isinstance(response["result"]["number"], int)  # assert not processed

web3/exceptions.py

@@ -327,6 +327,12 @@ class TaskNotRunning(Web3Exception):
         super().__init__(message)
 
 
+class PersistentConnectionClosedOK(Web3Exception):
+    """
+    Raised when a persistent connection is closed gracefully by the server.
+    """
+
+
 class Web3RPCError(Web3Exception):
     """
     Raised when a JSON-RPC response contains an error field.

web3/manager.py

@@ -20,9 +20,6 @@ from eth_utils.toolz import (
 from hexbytes import (
     HexBytes,
 )
-from websockets.exceptions import (
-    ConnectionClosedOK,
-)
 
 from web3._utils.batching import (
     RequestBatcher,
@@ -472,22 +469,50 @@ class RequestManager:
 
     # -- persistent connection -- #
 
-    async def send(self, method: RPCEndpoint, params: Any) -> RPCResponse:
+    async def socket_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
         provider = cast(PersistentConnectionProvider, self._provider)
         request_func = await provider.request_func(
             cast("AsyncWeb3", self.w3), cast("MiddlewareOnion", self.middleware_onion)
         )
         self.logger.debug(
-            "Making request to open socket connection: "
+            "Making request to open socket connection and waiting for response: "
             f"{provider.get_endpoint_uri_or_ipc_path()}, method: {method}"
         )
         response = await request_func(method, params)
         return await self._process_response(response)
 
+    async def send(self, method: RPCEndpoint, params: Any) -> None:
+        provider = cast(PersistentConnectionProvider, self._provider)
+        # run through the request processors of the middleware
+        for mw_class in self.middleware_onion.as_tuple_of_middleware():
+            mw = mw_class(self.w3)
+            method, params = mw.request_processor(method, params)
+
+        self.logger.debug(
+            "Sending request to open socket connection: "
+            f"{provider.get_endpoint_uri_or_ipc_path()}, method: {method}"
+        )
+        await provider.socket_send(provider.encode_rpc_request(method, params))
+
+    async def recv(self) -> RPCResponse:
+        provider = cast(PersistentConnectionProvider, self._provider)
+        self.logger.debug(
+            "Getting next response from open socket connection: "
+            f"{provider.get_endpoint_uri_or_ipc_path()}"
+        )
+        # pop from the queue since the listener task is responsible for reading
+        # directly from the socket
+        request_response_cache = self._request_processor._request_response_cache
+        _key, response = await request_response_cache.async_await_and_popitem(
+            last=False,
+            timeout=provider.request_timeout,
+        )
+        return await self._process_response(response)
+
     def _persistent_message_stream(self) -> "_AsyncPersistentMessageStream":
         return _AsyncPersistentMessageStream(self)
 
-    async def _get_next_message(self) -> Any:
+    async def _get_next_message(self) -> RPCResponse:
         return await self._message_stream().__anext__()
 
     async def _message_stream(self) -> AsyncGenerator[RPCResponse, None]:
@@ -515,12 +540,13 @@ class RequestManager:
                     # if response is an active subscription response, process it
                     yield await self._process_response(response)
             except TaskNotRunning:
+                await asyncio.sleep(0)
                 self._provider._handle_listener_task_exceptions()
                 self.logger.error(
                     "Message listener background task has stopped unexpectedly. "
                     "Stopping message stream."
                 )
-                raise StopAsyncIteration
+                return
 
     async def _process_response(self, response: RPCResponse) -> RPCResponse:
         provider = cast(PersistentConnectionProvider, self._provider)
@@ -586,7 +612,4 @@ class _AsyncPersistentMessageStream:
         return self
 
     async def __anext__(self) -> RPCResponse:
-        try:
-            return await self.manager._get_next_message()
-        except ConnectionClosedOK:
-            raise StopAsyncIteration
+        return await self.manager._get_next_message()

web3/module.py

@@ -138,7 +138,7 @@ def retrieve_async_method_call_fn(
 
             try:
                 method_str = cast(RPCEndpoint, method_str)
-                return await async_w3.manager.send(method_str, params)
+                return await async_w3.manager.socket_request(method_str, params)
             except Exception as e:
                 if (
                     cache_key is not None

web3/providers/persistent/async_ipc.py

@@ -11,11 +11,9 @@ from pathlib import (
 import sys
 from typing import (
     Any,
-    List,
     Optional,
     Tuple,
     Union,
-    cast,
 )
 
 from eth_utils import (
@@ -23,20 +21,12 @@ from eth_utils import (
 )
 
 from web3.types import (
-    RPCEndpoint,
     RPCResponse,
 )
 
 from . import (
     PersistentConnectionProvider,
 )
-from ..._utils.batching import (
-    BATCH_REQUEST_ID,
-    sort_batch_response_by_response_ids,
-)
-from ..._utils.caching import (
-    async_handle_request_caching,
-)
 from ...exceptions import (
     ProviderConnectionError,
     Web3TypeError,
@@ -91,12 +81,7 @@ class AsyncIPCProvider(PersistentConnectionProvider):
             return False
 
         try:
-            request_data = self.encode_rpc_request(
-                RPCEndpoint("web3_clientVersions"), []
-            )
-            self._writer.write(request_data)
-            current_request_id = json.loads(request_data)["id"]
-            await self._get_response_for_request_id(current_request_id, timeout=2)
+            await self.make_request("web3_clientVersion", [])
             return True
         except (OSError, ProviderConnectionError) as e:
             if show_traceback:
@@ -105,55 +90,33 @@ class AsyncIPCProvider(PersistentConnectionProvider):
                 )
             return False
 
-    async def _provider_specific_connect(self) -> None:
-        self._reader, self._writer = await async_get_ipc_socket(self.ipc_path)
-
-    async def _provider_specific_disconnect(self) -> None:
-        if self._writer and not self._writer.is_closing():
-            self._writer.close()
-            await self._writer.wait_closed()
-            self._writer = None
-        if self._reader:
-            self._reader = None
-
-    async def _reset_socket(self) -> None:
-        self._writer.close()
-        await self._writer.wait_closed()
-        self._reader, self._writer = await async_get_ipc_socket(self.ipc_path)
-
-    @async_handle_request_caching
-    async def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
+    async def socket_send(self, request_data: bytes) -> None:
         if self._writer is None:
             raise ProviderConnectionError(
                 "Connection to ipc socket has not been initiated for the provider."
             )
 
-        request_data = self.encode_rpc_request(method, params)
-        try:
-            self._writer.write(request_data)
-            await self._writer.drain()
-        except OSError as e:
-            # Broken pipe
-            if e.errno == errno.EPIPE:
-                # one extra attempt, then give up
-                await self._reset_socket()
-                self._writer.write(request_data)
-                await self._writer.drain()
+        return await asyncio.wait_for(
+            self._socket_send(request_data), timeout=self.request_timeout
+        )
 
-        current_request_id = json.loads(request_data)["id"]
-        response = await self._get_response_for_request_id(current_request_id)
+    async def socket_recv(self) -> RPCResponse:
+        while True:
+            # yield to the event loop to allow other tasks to run
+            await asyncio.sleep(0)
 
-        return response
+            try:
+                response, pos = self._decoder.raw_decode(self._raw_message)
+                self._raw_message = self._raw_message[pos:].lstrip()
+                return response
+            except JSONDecodeError:
+                # read more data from the socket if the current raw message is
+                # incomplete
+                self._raw_message += to_text(await self._reader.read(4096)).lstrip()
 
-    async def make_batch_request(
-        self, requests: List[Tuple[RPCEndpoint, Any]]
-    ) -> List[RPCResponse]:
-        if self._writer is None:
-            raise ProviderConnectionError(
-                "Connection to ipc socket has not been initiated for the provider."
-            )
+    # -- private methods -- #
 
-        request_data = self.encode_batch_rpc_request(requests)
+    async def _socket_send(self, request_data: bytes) -> None:
         try:
             self._writer.write(request_data)
             await self._writer.drain()
@@ -165,32 +128,24 @@ class AsyncIPCProvider(PersistentConnectionProvider):
                 self._writer.write(request_data)
                 await self._writer.drain()
 
-        response = cast(
-            List[RPCResponse], await self._get_response_for_request_id(BATCH_REQUEST_ID)
-        )
-        return response
-
-    async def _provider_specific_message_listener(self) -> None:
-        self._raw_message += to_text(await self._reader.read(4096)).lstrip()
+    async def _reset_socket(self) -> None:
+        self._writer.close()
+        await self._writer.wait_closed()
+        self._reader, self._writer = await async_get_ipc_socket(self.ipc_path)
 
-        while self._raw_message:
-            try:
-                response, pos = self._decoder.raw_decode(self._raw_message)
-            except JSONDecodeError:
-                break
+    async def _provider_specific_connect(self) -> None:
+        self._reader, self._writer = await async_get_ipc_socket(self.ipc_path)
 
-            if isinstance(response, list):
-                response = sort_batch_response_by_response_ids(response)
+    async def _provider_specific_disconnect(self) -> None:
+        if self._writer and not self._writer.is_closing():
+            self._writer.close()
+            await self._writer.wait_closed()
+            self._writer = None
+        if self._reader:
+            self._reader = None
 
-            is_subscription = (
-                response.get("method") == "eth_subscription"
-                if not isinstance(response, list)
-                else False
-            )
-            await self._request_processor.cache_raw_response(
-                response, subscription=is_subscription
-            )
-            self._raw_message = self._raw_message[pos:].lstrip()
+    async def _provider_specific_socket_reader(self) -> RPCResponse:
+        return await self.socket_recv()
 
     def _error_log_listener_task_exception(self, e: Exception) -> None:
         super()._error_log_listener_task_exception(e)

web3/providers/persistent/persistent.py

@@ -1,13 +1,17 @@
 from abc import (
     ABC,
+    abstractmethod,
 )
 import asyncio
+import json
 import logging
 from typing import (
     Any,
     List,
     Optional,
+    Tuple,
     Union,
+    cast,
 )
 
 from websockets import (
@@ -15,13 +19,20 @@ from websockets import (
     WebSocketException,
 )
 
+from web3._utils.batching import (
+    BATCH_REQUEST_ID,
+    sort_batch_response_by_response_ids,
+)
 from web3._utils.caching import (
+    async_handle_request_caching,
     generate_cache_key,
 )
 from web3.exceptions import (
+    PersistentConnectionClosedOK,
     ProviderConnectionError,
     TaskNotRunning,
     TimeExhausted,
+    Web3AttributeError,
 )
 from web3.providers.async_base import (
     AsyncJSONBaseProvider,
@@ -30,6 +41,7 @@ from web3.providers.persistent.request_processor import (
     RequestProcessor,
 )
 from web3.types import (
+    RPCEndpoint,
     RPCId,
     RPCResponse,
 )
@@ -70,7 +82,7 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
         elif hasattr(self, "ipc_path"):
             return str(self.ipc_path)
         else:
-            raise AttributeError(
+            raise Web3AttributeError(
                 "`PersistentConnectionProvider` must have either `endpoint_uri` or "
                 "`ipc_path` attribute."
             )
@@ -128,6 +140,44 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
             f"Successfully disconnected from: {self.get_endpoint_uri_or_ipc_path()}"
         )
 
+    @async_handle_request_caching
+    async def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
+        request_data = self.encode_rpc_request(method, params)
+        await self.socket_send(request_data)
+
+        current_request_id = json.loads(request_data)["id"]
+        response = await self._get_response_for_request_id(current_request_id)
+
+        return response
+
+    async def make_batch_request(
+        self, requests: List[Tuple[RPCEndpoint, Any]]
+    ) -> List[RPCResponse]:
+        request_data = self.encode_batch_rpc_request(requests)
+        await self.socket_send(request_data)
+
+        response = cast(
+            List[RPCResponse], await self._get_response_for_request_id(BATCH_REQUEST_ID)
+        )
+        return response
+
+    # -- abstract methods -- #
+
+    @abstractmethod
+    async def socket_send(self, request_data: bytes) -> None:
+        """
+        Send an encoded RPC request to the provider over the persistent connection.
+        """
+        raise NotImplementedError("Must be implemented by subclasses")
+
+    @abstractmethod
+    async def socket_recv(self) -> RPCResponse:
+        """
+        Receive, decode, and return an RPC response from the provider over the
+        persistent connection.
+        """
+        raise NotImplementedError("Must be implemented by subclasses")
+
     # -- private methods -- #
 
     async def _provider_specific_connect(self) -> None:
@@ -136,7 +186,7 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
     async def _provider_specific_disconnect(self) -> None:
         raise NotImplementedError("Must be implemented by subclasses")
 
-    async def _provider_specific_message_listener(self) -> None:
+    async def _provider_specific_socket_reader(self) -> RPCResponse:
         raise NotImplementedError("Must be implemented by subclasses")
 
     def _message_listener_callback(
@@ -158,8 +208,28 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
             # the use of sleep(0) seems to be the most efficient way to yield control
             # back to the event loop to share the loop with other tasks.
             await asyncio.sleep(0)
+
             try:
-                await self._provider_specific_message_listener()
+                response = await self._provider_specific_socket_reader()
+
+                if isinstance(response, list):
+                    response = sort_batch_response_by_response_ids(response)
+
+                subscription = (
+                    response.get("method") == "eth_subscription"
+                    if not isinstance(response, list)
+                    else False
+                )
+                await self._request_processor.cache_raw_response(
+                    response, subscription=subscription
+                )
+            except PersistentConnectionClosedOK as e:
+                self.logger.info(
+                    "Message listener background task has ended gracefully: "
+                    f"{e.user_message}"
+                )
+                # trigger a return to end the listener task and initiate the callback fn
+                return
             except Exception as e:
                 if not self.silence_listener_task_exceptions:
                     raise e
@@ -202,10 +272,6 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
             request_cache_key = generate_cache_key(request_id)
 
             while True:
-                # check if an exception was recorded in the listener task and raise it
-                # in the main loop if so
-                self._handle_listener_task_exceptions()
-
                 if request_cache_key in self._request_processor._request_response_cache:
                     self.logger.debug(
                         f"Popping response for id {request_id} from cache."
@@ -215,6 +281,9 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
                     )
                     return popped_response
                 else:
+                    # check if an exception was recorded in the listener task and raise
+                    # it in the main loop if so
+                    self._handle_listener_task_exceptions()
                     await asyncio.sleep(0)
 
         try:

web3/providers/persistent/persistent_connection.py

@@ -27,16 +27,58 @@ class PersistentConnection:
     def __init__(self, w3: "AsyncWeb3"):
         self._manager = w3.manager
 
-    # -- public methods -- #
     @property
     def subscriptions(self) -> Dict[str, Any]:
+        """
+        Return the active subscriptions on the persistent connection.
+
+        :return: The active subscriptions on the persistent connection.
+        :rtype: Dict[str, Any]
+        """
         return self._manager._request_processor.active_subscriptions
 
-    async def send(self, method: RPCEndpoint, params: Any) -> RPCResponse:
-        return await self._manager.send(method, params)
+    async def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
+        """
+        Make a request to the persistent connection and return the response. This method
+        does not process the response as it would when invoking a method via the
+        appropriate module on the `AsyncWeb3` instance,
+        e.g. `w3.eth.get_block("latest")`.
+
+        :param method: The RPC method, e.g. `eth_getBlockByNumber`.
+        :param params: The RPC method parameters, e.g. `["0x1337", False]`.
+
+        :return: The processed response from the persistent connection.
+        :rtype: RPCResponse
+        """
+        return await self._manager.socket_request(method, params)
+
+    async def send(self, method: RPCEndpoint, params: Any) -> None:
+        """
+        Send a raw, unprocessed message to the persistent connection.
 
-    async def recv(self) -> Any:
-        return await self._manager._get_next_message()
+        :param method: The RPC method, e.g. `eth_getBlockByNumber`.
+        :param params: The RPC method parameters, e.g. `["0x1337", False]`.
+
+        :return: None
+        """
+        await self._manager.send(method, params)
+
+    async def recv(self) -> RPCResponse:
+        """
+        Receive the next unprocessed response for a request from the persistent
+        connection.
+
+        :return: The next unprocessed response for a request from the persistent
+                 connection.
+        :rtype: RPCResponse
+        """
+        return await self._manager.recv()
 
     def process_subscriptions(self) -> "_AsyncPersistentMessageStream":
+        """
+        Asynchronous iterator that yields messages from the subscription message stream.
+
+        :return: The subscription message stream.
+        :rtype: _AsyncPersistentMessageStream
+        """
         return self._manager._persistent_message_stream()

web3/providers/persistent/websocket.py

@@ -5,11 +5,8 @@ import os
 from typing import (
     Any,
     Dict,
-    List,
     Optional,
-    Tuple,
     Union,
-    cast,
 )
 
 from eth_typing import (
@@ -25,17 +22,12 @@ from websockets.client import (
     connect,
 )
 from websockets.exceptions import (
+    ConnectionClosedOK,
     WebSocketException,
 )
 
-from web3._utils.batching import (
-    BATCH_REQUEST_ID,
-    sort_batch_response_by_response_ids,
-)
-from web3._utils.caching import (
-    async_handle_request_caching,
-)
 from web3.exceptions import (
+    PersistentConnectionClosedOK,
     ProviderConnectionError,
     Web3ValidationError,
 )
@@ -43,7 +35,6 @@ from web3.providers.persistent import (
     PersistentConnectionProvider,
 )
 from web3.types import (
-    RPCEndpoint,
     RPCResponse,
 )
 
@@ -122,18 +113,7 @@ class WebSocketProvider(PersistentConnectionProvider):
                 ) from e
             return False
 
-    async def _provider_specific_connect(self) -> None:
-        self._ws = await connect(self.endpoint_uri, **self.websocket_kwargs)
-
-    async def _provider_specific_disconnect(self) -> None:
-        if self._ws is not None and not self._ws.closed:
-            await self._ws.close()
-            self._ws = None
-
-    @async_handle_request_caching
-    async def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
-        request_data = self.encode_rpc_request(method, params)
-
+    async def socket_send(self, request_data: bytes) -> None:
         if self._ws is None:
             raise ProviderConnectionError(
                 "Connection to websocket has not been initiated for the provider."
@@ -143,44 +123,24 @@ class WebSocketProvider(PersistentConnectionProvider):
             self._ws.send(request_data), timeout=self.request_timeout
         )
 
-        current_request_id = json.loads(request_data)["id"]
-        response = await self._get_response_for_request_id(current_request_id)
-
-        return response
+    async def socket_recv(self) -> RPCResponse:
+        raw_response = await self._ws.recv()
+        return json.loads(raw_response)
 
-    async def make_batch_request(
-        self, requests: List[Tuple[RPCEndpoint, Any]]
-    ) -> List[RPCResponse]:
-        request_data = self.encode_batch_rpc_request(requests)
+    # -- private methods -- #
 
-        if self._ws is None:
-            raise ProviderConnectionError(
-                "Connection to websocket has not been initiated for the provider."
-            )
-
-        await asyncio.wait_for(
-            self._ws.send(request_data), timeout=self.request_timeout
-        )
-
-        response = cast(
-            List[RPCResponse],
-            await self._get_response_for_request_id(BATCH_REQUEST_ID),
-        )
-        return response
-
-    async def _provider_specific_message_listener(self) -> None:
-        async for raw_message in self._ws:
-            await asyncio.sleep(0)
+    async def _provider_specific_connect(self) -> None:
+        self._ws = await connect(self.endpoint_uri, **self.websocket_kwargs)
 
-            response = json.loads(raw_message)
-            if isinstance(response, list):
-                response = sort_batch_response_by_response_ids(response)
+    async def _provider_specific_disconnect(self) -> None:
+        if self._ws is not None and not self._ws.closed:
+            await self._ws.close()
+            self._ws = None
 
-            subscription = (
-                response.get("method") == "eth_subscription"
-                if not isinstance(response, list)
-                else False
-            )
-            await self._request_processor.cache_raw_response(
-                response, subscription=subscription
+    async def _provider_specific_socket_reader(self) -> RPCResponse:
+        try:
+            return await self.socket_recv()
+        except ConnectionClosedOK:
+            raise PersistentConnectionClosedOK(
+                user_message="WebSocket connection received `ConnectionClosedOK`."
             )

web3/utils/caching.py

@@ -1,6 +1,8 @@
+import asyncio
 from collections import (
     OrderedDict,
 )
+import time
 from typing import (
     Any,
     Dict,
@@ -46,8 +48,30 @@ class SimpleCache:
 
         return self._data.pop(key)
 
+    def popitem(self, last: bool = True) -> Tuple[str, Any]:
+        return self._data.popitem(last=last)
+
     def __contains__(self, key: str) -> bool:
         return key in self._data
 
     def __len__(self) -> int:
         return len(self._data)
+
+    # -- async utility methods -- #
+
+    async def async_await_and_popitem(
+        self, last: bool = True, timeout: float = 10.0
+    ) -> Tuple[str, Any]:
+        start = time.time()
+        end_time = start + timeout
+        while True:
+            await asyncio.sleep(0)
+            try:
+                return self.popitem(last=last)
+            except KeyError:
+                now = time.time()
+                if now >= end_time:
+                    raise asyncio.TimeoutError(
+                        "Timeout waiting for item to be available"
+                    )
+                await asyncio.sleep(min(0.1, end_time - now))

{web3-7.0.0b7.dist-info → web3-7.0.0b8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: web3
-Version: 7.0.0b7
+Version: 7.0.0b8
 Summary: web3: A Python library for interacting with Ethereum
 Home-page: https://github.com/ethereum/web3.py
 Author: The Ethereum Foundation
@@ -79,7 +79,9 @@ Requires-Dist: pytest >=7.0.0 ; extra == 'test'
 [![Python versions](https://img.shields.io/pypi/pyversions/web3.svg)](https://pypi.python.org/pypi/web3)
 [![Docs build](https://readthedocs.org/projects/web3py/badge/?version=latest)](https://web3py.readthedocs.io/en/latest/?badge=latest)
 
-A Python library for interacting with Ethereum.
+## A Python Library for Interacting with Ethereum
+
+web3.py allows you to interact with the Ethereum blockchain using Python, enabling you to build decentralized applications, interact with smart contracts, and much more.
 
 - Python 3.8+ support
 
@@ -94,7 +96,7 @@ ______________________________________________________________________
 
 For additional guides, examples, and APIs, see the [documentation](https://web3py.readthedocs.io/en/latest/).
 
-## Want to help?
+## Want to Help?
 
 Want to file a bug, contribute some code, or improve documentation? Excellent! Read up on our
 guidelines for [contributing](https://web3py.readthedocs.io/en/latest/contributing.html),
@@ -103,4 +105,6 @@ then check out issues that are labeled
 
 ______________________________________________________________________
 
-#### Questions on implementation or usage? Join the conversation on [discord](https://discord.gg/GHryRvPB84).
+## Questions on Implementation or Usage?
+
+Join the conversation in the Ethereum Python Community [Discord](https://discord.gg/GHryRvPB84).

{web3-7.0.0b7.dist-info → web3-7.0.0b8.dist-info}/RECORD

@@ -14,13 +14,13 @@ ens/specs/normalization_spec.json,sha256=xn3N9a-6KHMLu3MeCBsmOxSzIzUQykzE9EscKK1
 web3/__init__.py,sha256=P11QAEV_GYoZq9ij8gDzFx5tKzJY2aMXG-keg2Lg1xs,1277
 web3/constants.py,sha256=eQLRQVMFPbgpOjjkPTMHkY-syncJuO-sPX5UrCSRjzQ,564
 web3/datastructures.py,sha256=Yc45cXgoXvhV0HPvnmkFFOEVDtLr-Pftc_f5q-uQY1M,10939
-web3/exceptions.py,sha256=VoB2dwZagBVTJn9712xcdJJPyq_bwhFt4prf2H9ukMs,8742
+web3/exceptions.py,sha256=gpFB_l-MqCrBxW5CaSh9WpvdC4vdVCxxM8FVNc744wk,8887
 web3/geth.py,sha256=IQYeqiVSqcskuXWgDR35UBuVsD-whhvTpDltO4vvCvE,5867
 web3/logs.py,sha256=ROs-mDMH_ZOecE7hfbWA5yp27G38FbLjX4lO_WtlZxQ,198
 web3/main.py,sha256=AFAV0Y_zIjo9ZuAlQTEMbUPN5iGyHRpS8mS-wFkw8-E,14350
-web3/manager.py,sha256=9ze-9eluei5_CCA3G-kMP_KWzllD2iv9oJQbeXyU3ao,20730
+web3/manager.py,sha256=X2unu2J5EXCmLVx6MG0dMSxR3mqis-R_PF-KEaoOzfw,21950
 web3/method.py,sha256=Uv29Vng93VC5-HHeRok30PUbGCg42SNA2YsxiweTgWA,8593
-web3/module.py,sha256=Djz589nMXZzelVELGPzsw9CHgqmKTUwOZ7pTgkCPs-U,5996
+web3/module.py,sha256=rz_cqGNlzLGCHLE8zDf-hW4SpDfLgzVEW8pgDxM45Y0,6006
 web3/net.py,sha256=Y3vPzHWVFkfHEZoJxjDOt4tp5ERmZrMuyi4ZFOLmIeA,1562
 web3/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 web3/testing.py,sha256=Ury_-7XSstJ8bkCfdGEi4Cr76QzSfW7v_zfPlDlLJj0,923
@@ -49,7 +49,7 @@ web3/_utils/http.py,sha256=NNcbf_K814Ggpt0YiGTWjV3CCUrLkpZpQDru4f-3C9E,235
 web3/_utils/http_session_manager.py,sha256=zOIEXELSYsbIq49JUJFY1jN5iPjENBkX1CPucqE3LNE,10726
 web3/_utils/hypothesis.py,sha256=4Cm4iOWv-uP9irg_Pv63kYNDYUAGhnUH6fOPWRw3A0g,209
 web3/_utils/math.py,sha256=4oU5YdbQBXElxK00CxmUZ94ApXFu9QT_TrO0Kho1HTs,1083
-web3/_utils/method_formatters.py,sha256=khFByaPfqy6_BjxznaNiO04fgMYTRYwD-7nIhXmNT6I,33507
+web3/_utils/method_formatters.py,sha256=nVKmwq9WWxtecACBNaLlZaVRQdv2HKyADsdYd3RIUNE,34213
 web3/_utils/module.py,sha256=GuVePloTlIBZwFDOjg0zasp53HSJ32umxN1nQhqW-8Y,3175
 web3/_utils/normalizers.py,sha256=Q5urvzI9nbtNiqzhrrIMtZ5NqOAxWE4Xp5srZFs0Baw,7392
 web3/_utils/rpc_abi.py,sha256=ey3rw3j2jC9ybs1FZpyCPReA0Mra7TwRX1a7GTtOPeE,8392
@@ -86,12 +86,12 @@ web3/_utils/contract_sources/contract_data/storage_contract.py,sha256=vP1Qaekjld
 web3/_utils/contract_sources/contract_data/string_contract.py,sha256=y6EFnum4zDrrRUmuXExCGr2bhZMrerbMiqJiamUU2Tw,11210
 web3/_utils/contract_sources/contract_data/tuple_contracts.py,sha256=QuqPfv3BxjqDjeLScnxJDEPtPZMAB4jwHxsAOeVd6kk,23176
 web3/_utils/module_testing/__init__.py,sha256=tPFAaX7xOR50CPTq24UeY-1CX1LQxxmEOPr0-tIRkoE,376
-web3/_utils/module_testing/eth_module.py,sha256=sMrza5Yg_Sw8xdCUnSZL_Kzj7MyZL_Qxv1ady43vCn8,185007
+web3/_utils/module_testing/eth_module.py,sha256=5fr1PSUECdijf5Me7G6ZSs98tDRfpFjhAQQqzSnT23U,185007
 web3/_utils/module_testing/go_ethereum_admin_module.py,sha256=_c-6SyzZkfAJ-7ySXUpw9FEr4cg-ShRdAGSAHWanCtY,3406
 web3/_utils/module_testing/go_ethereum_txpool_module.py,sha256=5f8XL8-2x3keyGRaITxMQYl9oQzjgqGn8zobB-j9BPs,1176
-web3/_utils/module_testing/module_testing_utils.py,sha256=m5-mnIf29F2hGgFX-7kv0kdESTcvMu9UtzK0RGT3XTU,5908
+web3/_utils/module_testing/module_testing_utils.py,sha256=UCP95K8YWX6zTXspzmVxlSUN8TMaK6-Hzvq2W_VNZNA,5956
 web3/_utils/module_testing/net_module.py,sha256=ifUTC-5fTcQbwpm0X09OdD5RSPnn00T8klFeYe8tTm4,1272
-web3/_utils/module_testing/persistent_connection_provider.py,sha256=py52pWgdP4E3JORGTFo-CEzKqb56FwKSlzdaH-i7oQs,16618
+web3/_utils/module_testing/persistent_connection_provider.py,sha256=SciOaB4p56M0MGsPr5C_qO7_mJ_hHuJo4ONzTHTiCX4,17816
 web3/_utils/module_testing/utils.py,sha256=7jYtIKfOdrQnj1pDB0gLyoN_b8U3ZyEYbMU4dxaLljs,10023
 web3/_utils/module_testing/web3_module.py,sha256=lfLOshDOr-SpnaN0iVcff-q-HUOw8XSBIwQeBO7TaJo,25121
 web3/auto/__init__.py,sha256=ZbzAiCZMdt_tCTTPvH6t8NCVNroKKkt7TSVBBNR74Is,44
@@ -136,12 +136,12 @@ web3/providers/eth_tester/defaults.py,sha256=9aPe0x2C5wahdGI_rZjiGR3Fe2LbMjKWH9o
 web3/providers/eth_tester/main.py,sha256=U19sNDeHs36A4IYQ0HFGyXdZvuXiYvoSMNWVuki0WwI,7807
 web3/providers/eth_tester/middleware.py,sha256=3h8q1WBu5CLiBYwonWFeAR_5pUy_vqgiDmi7wOzuorc,12971
 web3/providers/persistent/__init__.py,sha256=X7tFKJL5BXSwciq5_bRwGRB6bfdWBkIPPWMqCjXIKrA,411
-web3/providers/persistent/async_ipc.py,sha256=YtSZWlKwnr78ofBW31jTPpDAOK_Cs305oT-Y7Uhdhnw,6213
-web3/providers/persistent/persistent.py,sha256=2dJtCfhK_Sm6wrEx807XbO0YhADM27agEI8sEgNwoWE,8918
-web3/providers/persistent/persistent_connection.py,sha256=56yjpwDMM2phkJ_M5_QB-A6_CjZc5VrkWhNDweA70d0,1109
+web3/providers/persistent/async_ipc.py,sha256=7xgk9hxEXCA2yyHoRSFlDjPWTM_EJN7OVjRHTmPl9ts,4692
+web3/providers/persistent/persistent.py,sha256=8dezjPWoabZ6Wk47t7BRAksj3eAGeQnmpiZ6XafcnqQ,11344
+web3/providers/persistent/persistent_connection.py,sha256=RCoYNobRE9IMtxhByT0gTNby4eFqAOEDAqYzphtHNB8,2683
 web3/providers/persistent/request_processor.py,sha256=E1jJwsvrPBTbufCy2LeNvMdRXf1H-Iz5WTsqyFvPGc0,14504
 web3/providers/persistent/utils.py,sha256=gfY7w1HB8xuE7OujSrbwWYjQuQ8nzRBoxoL8ESinqWM,1140
-web3/providers/persistent/websocket.py,sha256=L0jIBaSq2XBAPbzpJgBjDsUB0sfIl8p4af5fqIl56a0,5446
+web3/providers/persistent/websocket.py,sha256=2EuBOdkEBTp6ge53UlJbjV0eAUJ143TkmqrOLTQl9kk,4231
 web3/providers/rpc/__init__.py,sha256=mObsuwjr7xyHnnRlwzsmbp2JgZdn2NXSSctvpye4AuQ,149
 web3/providers/rpc/async_rpc.py,sha256=hibsCoyrAD199ExAEyHRsEnZ0_rDP_2EC2k5g-D2zhw,5609
 web3/providers/rpc/rpc.py,sha256=ePlGdlkvQTaf2Wi2khxiY-rRj-OFcPlpDMuTPLKaAyU,5655
@@ -158,10 +158,10 @@ web3/utils/__init__.py,sha256=gDQ032U1WUUmzOdrrIdcQS4s_x5gUeRHV7xQ7kTClJs,596
 web3/utils/abi.py,sha256=naNkD7_XQGV8hd4CkxytLKWCcgzUjkb7q3ERwRVNICI,498
 web3/utils/address.py,sha256=KC_IpEbixSCuMhaW6V2QCyyJTYKYGS9c8QtI9_aH7zQ,967
 web3/utils/async_exception_handling.py,sha256=GZWSBFC0-Wmwz1tpTie-1AKRbIQH7JkmBpf5bXrUTzY,3320
-web3/utils/caching.py,sha256=4U-vh61m1dlslwEn_Nl7ybIlMF4W2IAcvMTH-iFzrNM,1618
+web3/utils/caching.py,sha256=IG_IxW-jyiRklrIyUgjOj3GQvcXrok0KLDX3ch_6wuA,2390
 web3/utils/exception_handling.py,sha256=k31JROfUyKIm9PoEWOtYSkIq9wL8SOBwQfnSLNQyfnM,3097
-web3-7.0.0b7.dist-info/LICENSE,sha256=ScEyLx1vWrB0ybKiZKKTXm5QhVksHCEUtTp4lwYV45I,1095
-web3-7.0.0b7.dist-info/METADATA,sha256=RNKH0xkVnw06eSlXOfiad-MEcEfrii1_9W7EeQRb9L4,4813
-web3-7.0.0b7.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
-web3-7.0.0b7.dist-info/top_level.txt,sha256=iwupuJh7wgypXrpk_awszyri3TahRr5vxSphNyvt1bU,9
-web3-7.0.0b7.dist-info/RECORD,,
+web3-7.0.0b8.dist-info/LICENSE,sha256=ScEyLx1vWrB0ybKiZKKTXm5QhVksHCEUtTp4lwYV45I,1095
+web3-7.0.0b8.dist-info/METADATA,sha256=ZrFhndCk4vfboI5JrBJX90Pai4HHeQNZ8KRtYAz_dB4,5015
+web3-7.0.0b8.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91
+web3-7.0.0b8.dist-info/top_level.txt,sha256=iwupuJh7wgypXrpk_awszyri3TahRr5vxSphNyvt1bU,9
+web3-7.0.0b8.dist-info/RECORD,,

{web3-7.0.0b7.dist-info → web3-7.0.0b8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.1.1)
+Generator: setuptools (71.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any