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

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/providers/rpc/__init__.py

@@ -4,3 +4,8 @@ from .async_rpc import (
 from .rpc import (
     HTTPProvider,
 )
+
+__all__ = [
+    "AsyncHTTPProvider",
+    "HTTPProvider",
+]

web3/providers/rpc/async_rpc.py

@@ -29,11 +29,6 @@ from web3._utils.empty import (
 from web3._utils.http import (
     construct_user_agent,
 )
-from web3._utils.request import (
-    async_cache_and_return_session as _async_cache_and_return_session,
-    async_make_post_request,
-    get_default_http_endpoint,
-)
 from web3.types import (
     RPCEndpoint,
     RPCResponse,
@@ -45,6 +40,9 @@ from ..._utils.batching import (
 from ..._utils.caching import (
     async_handle_request_caching,
 )
+from ..._utils.http_session_manager import (
+    HTTPSessionManager,
+)
 from ..async_base import (
     AsyncJSONBaseProvider,
 )
@@ -63,13 +61,17 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
         self,
         endpoint_uri: Optional[Union[URI, str]] = None,
         request_kwargs: Optional[Any] = None,
-        exception_retry_configuration: Union[
-            ExceptionRetryConfiguration, Empty
+        exception_retry_configuration: Optional[
+            Union[ExceptionRetryConfiguration, Empty]
         ] = empty,
         **kwargs: Any,
     ) -> None:
+        self._request_session_manager = HTTPSessionManager()
+
         if endpoint_uri is None:
-            self.endpoint_uri = get_default_http_endpoint()
+            self.endpoint_uri = (
+                self._request_session_manager.get_default_http_endpoint()
+            )
         else:
             self.endpoint_uri = URI(endpoint_uri)
 
@@ -79,7 +81,9 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
         super().__init__(**kwargs)
 
     async def cache_async_session(self, session: ClientSession) -> ClientSession:
-        return await _async_cache_and_return_session(self.endpoint_uri, session)
+        return await self._request_session_manager.async_cache_and_return_session(
+            self.endpoint_uri, session
+        )
 
     def __str__(self) -> str:
         return f"RPC connection {self.endpoint_uri}"
@@ -123,7 +127,7 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
         ):
             for i in range(self.exception_retry_configuration.retries):
                 try:
-                    return await async_make_post_request(
+                    return await self._request_session_manager.async_make_post_request(
                         self.endpoint_uri, request_data, **self.get_request_kwargs()
                     )
                 except tuple(self.exception_retry_configuration.errors):
@@ -136,7 +140,7 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
                         raise
             return None
         else:
-            return await async_make_post_request(
+            return await self._request_session_manager.async_make_post_request(
                 self.endpoint_uri, request_data, **self.get_request_kwargs()
             )
 
@@ -159,7 +163,7 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
     ) -> List[RPCResponse]:
         self.logger.debug(f"Making batch request HTTP - uri: `{self.endpoint_uri}`")
         request_data = self.encode_batch_rpc_request(batch_requests)
-        raw_response = await async_make_post_request(
+        raw_response = await self._request_session_manager.async_make_post_request(
             self.endpoint_uri, request_data, **self.get_request_kwargs()
         )
         self.logger.debug("Received batch response HTTP.")

web3/providers/rpc/rpc.py

@@ -27,11 +27,6 @@ from web3._utils.empty import (
 from web3._utils.http import (
     construct_user_agent,
 )
-from web3._utils.request import (
-    cache_and_return_session,
-    get_default_http_endpoint,
-    make_post_request,
-)
 from web3.types import (
     RPCEndpoint,
     RPCResponse,
@@ -43,6 +38,9 @@ from ..._utils.batching import (
 from ..._utils.caching import (
     handle_request_caching,
 )
+from ..._utils.http_session_manager import (
+    HTTPSessionManager,
+)
 from ..base import (
     JSONBaseProvider,
 )
@@ -67,13 +65,17 @@ class HTTPProvider(JSONBaseProvider):
         endpoint_uri: Optional[Union[URI, str]] = None,
         request_kwargs: Optional[Any] = None,
         session: Optional[Any] = None,
-        exception_retry_configuration: Union[
-            ExceptionRetryConfiguration, Empty
+        exception_retry_configuration: Optional[
+            Union[ExceptionRetryConfiguration, Empty]
         ] = empty,
         **kwargs: Any,
     ) -> None:
+        self._request_session_manager = HTTPSessionManager()
+
         if endpoint_uri is None:
-            self.endpoint_uri = get_default_http_endpoint()
+            self.endpoint_uri = (
+                self._request_session_manager.get_default_http_endpoint()
+            )
         else:
             self.endpoint_uri = URI(endpoint_uri)
 
@@ -81,7 +83,9 @@ class HTTPProvider(JSONBaseProvider):
         self._exception_retry_configuration = exception_retry_configuration
 
         if session:
-            cache_and_return_session(self.endpoint_uri, session)
+            self._request_session_manager.cache_and_return_session(
+                self.endpoint_uri, session
+            )
 
         super().__init__(**kwargs)
 
@@ -131,7 +135,7 @@ class HTTPProvider(JSONBaseProvider):
         ):
             for i in range(self.exception_retry_configuration.retries):
                 try:
-                    return make_post_request(
+                    return self._request_session_manager.make_post_request(
                         self.endpoint_uri, request_data, **self.get_request_kwargs()
                     )
                 except tuple(self.exception_retry_configuration.errors) as e:
@@ -144,7 +148,7 @@ class HTTPProvider(JSONBaseProvider):
                         raise e
             return None
         else:
-            return make_post_request(
+            return self._request_session_manager.make_post_request(
                 self.endpoint_uri, request_data, **self.get_request_kwargs()
             )
 
@@ -167,7 +171,7 @@ class HTTPProvider(JSONBaseProvider):
     ) -> List[RPCResponse]:
         self.logger.debug(f"Making batch request HTTP, uri: `{self.endpoint_uri}`")
         request_data = self.encode_batch_rpc_request(batch_requests)
-        raw_response = make_post_request(
+        raw_response = self._request_session_manager.make_post_request(
             self.endpoint_uri, request_data, **self.get_request_kwargs()
         )
         self.logger.debug("Received batch response HTTP.")

web3/providers/rpc/utils.py

@@ -19,9 +19,6 @@ REQUEST_RETRY_ALLOWLIST = [
     "evm",
     "eth_protocolVersion",
     "eth_syncing",
-    "eth_coinbase",
-    "eth_mining",
-    "eth_hashrate",
     "eth_chainId",
     "eth_gasPrice",
     "eth_accounts",