web3 6.18.0__py3-none-any.whl → 6.19.0__py3-none-any.whl

web3/_utils/module_testing/module_testing_utils.py

@@ -193,6 +193,12 @@ class WebsocketMessageStreamMock:
         self.messages = deque(messages) if messages else deque()
         self.raise_exception = raise_exception
 
+    def __await__(self) -> Generator[Any, Any, "Self"]:
+        async def __async_init__() -> "Self":
+            return self
+
+        return __async_init__().__await__()
+
     def __aiter__(self) -> "Self":
         return self
 
@@ -205,6 +211,13 @@ class WebsocketMessageStreamMock:
 
         return self.messages.popleft()
 
+    @staticmethod
+    async def pong() -> Literal[False]:
+        return False
+
+    async def connect(self) -> None:
+        pass
+
     async def send(self, data: bytes) -> None:
         pass
 

web3/exceptions.py

@@ -1,6 +1,7 @@
 import datetime
 import time
 from typing import (
+    TYPE_CHECKING,
     Any,
     Dict,
     Optional,
@@ -15,6 +16,9 @@ from web3.types import (
     BlockData,
 )
 
+if TYPE_CHECKING:
+    import asyncio
+
 
 class Web3Exception(Exception):
     """
@@ -341,7 +345,21 @@ class BadResponseFormat(Web3Exception):
     Raised when a JSON-RPC response comes back in an unexpected format
     """
 
-    pass
+
+class TaskNotRunning(Web3Exception):
+    """
+    Used to signal between asyncio contexts that a task that is being awaited
+    is not currently running.
+    """
+
+    def __init__(
+        self, task: "asyncio.Task[Any]", message: Optional[str] = None
+    ) -> None:
+        self.task = task
+        if message is None:
+            message = f"Task {task} is not running."
+        self.message = message
+        super().__init__(message)
 
 
 class MethodUnavailable(Web3Exception):

web3/main.py

@@ -573,12 +573,9 @@ class _PersistentConnectionWeb3(AsyncWeb3):
 
     # async for w3 in w3.persistent_websocket(provider)
     async def __aiter__(self) -> AsyncIterator[Self]:
-        if not await self.provider.is_connected():
-            await self.provider.connect()
-
+        provider = self.provider
         while True:
-            try:
-                yield self
-            except Exception:
-                # provider should handle connection / reconnection
-                continue
+            await provider.connect()
+            yield self
+            provider.logger.error("Connection interrupted, attempting to reconnect...")
+            await provider.disconnect()

web3/manager.py

@@ -35,6 +35,7 @@ from web3.exceptions import (
     BadResponseFormat,
     MethodUnavailable,
     ProviderConnectionError,
+    TaskNotRunning,
 )
 from web3.middleware import (
     abi_middleware,
@@ -377,14 +378,24 @@ class RequestManager:
             raise ProviderConnectionError("No listener found for websocket connection.")
 
         while True:
-            response = await self._request_processor.pop_raw_response(subscription=True)
-            if (
-                response is not None
-                and response.get("params", {}).get("subscription")
-                in self._request_processor.active_subscriptions
-            ):
-                # if response is an active subscription response, process it
-                yield await self._process_ws_response(response)
+            try:
+                response = await self._request_processor.pop_raw_response(
+                    subscription=True
+                )
+                if (
+                    response is not None
+                    and response.get("params", {}).get("subscription")
+                    in self._request_processor.active_subscriptions
+                ):
+                    # if response is an active subscription response, process it
+                    yield await self._process_ws_response(response)
+            except TaskNotRunning:
+                self._provider._handle_listener_task_exceptions()
+                self.logger.error(
+                    "Message listener background task has stopped unexpectedly. "
+                    "Stopping message stream."
+                )
+                raise StopAsyncIteration
 
     async def _process_ws_response(self, response: RPCResponse) -> RPCResponse:
         provider = cast(PersistentConnectionProvider, self._provider)

web3/providers/persistent.py

@@ -7,16 +7,30 @@ from typing import (
     Optional,
 )
 
-from websockets.legacy.client import (
+from websockets import (
+    ConnectionClosed,
     WebSocketClientProtocol,
+    WebSocketException,
 )
 
+from web3._utils.caching import (
+    generate_cache_key,
+)
+from web3.exceptions import (
+    ProviderConnectionError,
+    TaskNotRunning,
+    TimeExhausted,
+)
 from web3.providers.async_base import (
     AsyncJSONBaseProvider,
 )
 from web3.providers.websocket.request_processor import (
     RequestProcessor,
 )
+from web3.types import (
+    RPCId,
+    RPCResponse,
+)
 
 DEFAULT_PERSISTENT_CONNECTION_TIMEOUT = 50.0
 
@@ -26,6 +40,8 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
     has_persistent_connection = True
     endpoint_uri: Optional[str] = None
 
+    _max_connection_retries: int = 5
+
     _ws: Optional[WebSocketClientProtocol] = None
     _request_processor: RequestProcessor
     _message_listener_task: Optional["asyncio.Task[None]"] = None
@@ -36,6 +52,7 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
         request_timeout: float = DEFAULT_PERSISTENT_CONNECTION_TIMEOUT,
         subscription_response_queue_size: int = 500,
         request_information_cache_size: int = 500,
+        silence_listener_task_exceptions: bool = False,
     ) -> None:
         super().__init__()
         self._request_processor = RequestProcessor(
@@ -44,12 +61,154 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
             request_information_cache_size=request_information_cache_size,
         )
         self.request_timeout = request_timeout
+        self.silence_listener_task_exceptions = silence_listener_task_exceptions
 
     async def connect(self) -> None:
-        raise NotImplementedError("Must be implemented by subclasses")
+        _connection_attempts = 0
+        _backoff_rate_change = 1.75
+        _backoff_time = 1.75
+
+        while _connection_attempts != self._max_connection_retries:
+            try:
+                _connection_attempts += 1
+                self.logger.info(f"Connecting to: {self.endpoint_uri}")
+                await self._provider_specific_connect()
+                self._message_listener_task = asyncio.create_task(
+                    self._message_listener()
+                )
+                self._message_listener_task.add_done_callback(
+                    self._message_listener_callback
+                )
+                self.logger.info(f"Successfully connected to: {self.endpoint_uri}")
+                break
+            except (WebSocketException, OSError) as e:
+                if _connection_attempts == self._max_connection_retries:
+                    raise ProviderConnectionError(
+                        f"Could not connect to: {self.endpoint_uri}. "
+                        f"Retries exceeded max of {self._max_connection_retries}."
+                    ) from e
+                self.logger.info(
+                    f"Could not connect to: {self.endpoint_uri}. "
+                    f"Retrying in {round(_backoff_time, 1)} seconds.",
+                    exc_info=True,
+                )
+                await asyncio.sleep(_backoff_time)
+                _backoff_time *= _backoff_rate_change
 
     async def disconnect(self) -> None:
+        try:
+            if self._message_listener_task:
+                self._message_listener_task.cancel()
+                await self._message_listener_task
+        except (asyncio.CancelledError, StopAsyncIteration, ConnectionClosed):
+            pass
+        finally:
+            self._message_listener_task = None
+            self.logger.info("Message listener background task successfully shut down.")
+
+        await self._provider_specific_disconnect()
+        self._request_processor.clear_caches()
+        self.logger.info(f"Successfully disconnected from: {self.endpoint_uri}")
+
+    # -- private methods -- #
+
+    async def _provider_specific_connect(self) -> None:
         raise NotImplementedError("Must be implemented by subclasses")
 
-    async def _ws_message_listener(self) -> None:
+    async def _provider_specific_disconnect(self) -> None:
         raise NotImplementedError("Must be implemented by subclasses")
+
+    async def _provider_specific_message_listener(self) -> None:
+        raise NotImplementedError("Must be implemented by subclasses")
+
+    def _message_listener_callback(
+        self, message_listener_task: "asyncio.Task[None]"
+    ) -> None:
+        # Puts a `TaskNotRunning` in the queue to signal the end of the listener task
+        # to any running subscription streams that are awaiting a response.
+        self._request_processor._subscription_response_queue.put_nowait(
+            TaskNotRunning(message_listener_task)
+        )
+
+    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."
+        )
+        while True:
+            # 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()
+            except Exception as e:
+                if not self.silence_listener_task_exceptions:
+                    raise e
+                else:
+                    self._error_log_listener_task_exception(e)
+
+    def _error_log_listener_task_exception(self, e: Exception) -> None:
+        """
+        When silencing listener task exceptions, this method is used to log the
+        exception and keep the listener task alive. Override this method to fine-tune
+        error logging behavior for the implementation class.
+        """
+        self.logger.error(
+            "Exception caught in listener, error logging and keeping "
+            "listener background task alive."
+            f"\n    error={e.__class__.__name__}: {e}"
+        )
+
+    def _handle_listener_task_exceptions(self) -> None:
+        """
+        Should be called every time a `PersistentConnectionProvider` is polling for
+        messages in the main loop. If the message listener task has completed and an
+        exception was recorded, raise the exception in the main loop.
+        """
+        msg_listener_task = getattr(self, "_message_listener_task", None)
+        if (
+            msg_listener_task
+            and msg_listener_task.done()
+            and msg_listener_task.exception()
+        ):
+            raise msg_listener_task.exception()
+
+    async def _get_response_for_request_id(
+        self, request_id: RPCId, timeout: Optional[float] = None
+    ) -> RPCResponse:
+        if timeout is None:
+            timeout = self.request_timeout
+
+        async def _match_response_id_to_request_id() -> RPCResponse:
+            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."
+                    )
+                    popped_response = await self._request_processor.pop_raw_response(
+                        cache_key=request_cache_key,
+                    )
+                    return popped_response
+                else:
+                    await asyncio.sleep(0)
+
+        try:
+            # Add the request timeout around the while loop that checks the request
+            # cache. If the request is not in the cache within the request_timeout,
+            # raise ``TimeExhausted``.
+            return await asyncio.wait_for(_match_response_id_to_request_id(), timeout)
+        except asyncio.TimeoutError:
+            raise TimeExhausted(
+                f"Timed out waiting for response with request id `{request_id}` after "
+                f"{self.request_timeout} second(s). This may be due to the provider "
+                "not returning a response with the same id that was sent in the "
+                "request or an exception raised during the request was caught and "
+                "allowed to continue."
+            )

web3/providers/websocket/request_processor.py

@@ -2,19 +2,26 @@ import asyncio
 from copy import (
     copy,
 )
+import sys
 from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
     Dict,
+    Generic,
     Optional,
     Tuple,
+    TypeVar,
+    Union,
 )
 
 from web3._utils.caching import (
     RequestInformation,
     generate_cache_key,
 )
+from web3.exceptions import (
+    TaskNotRunning,
+)
 from web3.types import (
     RPCEndpoint,
     RPCResponse,
@@ -28,6 +35,34 @@ if TYPE_CHECKING:
         PersistentConnectionProvider,
     )
 
+T = TypeVar("T")
+
+# TODO: This is an ugly hack for python 3.8. Remove this after we drop support for it
+#  and use `asyncio.Queue[T]` type directly in the `TaskReliantQueue` class.
+if sys.version_info >= (3, 9):
+
+    class _TaskReliantQueue(asyncio.Queue[T], Generic[T]):
+        pass
+
+else:
+
+    class _TaskReliantQueue(asyncio.Queue, Generic[T]):  # type: ignore
+        pass
+
+
+class TaskReliantQueue(_TaskReliantQueue[T]):
+    """
+    A queue that relies on a task to be running to process items in the queue.
+    """
+
+    async def get(self) -> T:
+        item = await super().get()
+        if isinstance(item, Exception):
+            # if the item is an exception, raise it so the task can handle this case
+            # more gracefully
+            raise item
+        return item
+
 
 class RequestProcessor:
     _subscription_queue_synced_with_ws_stream: bool = False
@@ -41,9 +76,9 @@ class RequestProcessor:
         self._provider = provider
 
         self._request_response_cache: SimpleCache = SimpleCache(500)
-        self._subscription_response_queue: asyncio.Queue[RPCResponse] = asyncio.Queue(
-            maxsize=subscription_response_queue_size
-        )
+        self._subscription_response_queue: TaskReliantQueue[
+            Union[RPCResponse, TaskNotRunning]
+        ] = TaskReliantQueue(maxsize=subscription_response_queue_size)
         self._request_information_cache: SimpleCache = SimpleCache(
             request_information_cache_size
         )
@@ -203,7 +238,7 @@ class RequestProcessor:
     ) -> None:
         if subscription:
             if self._subscription_response_queue.full():
-                self._provider.logger.info(
+                self._provider.logger.debug(
                     "Subscription queue is full. Waiting for provider to consume "
                     "messages before caching."
                 )
@@ -276,6 +311,6 @@ class RequestProcessor:
 
         self._request_information_cache.clear()
         self._request_response_cache.clear()
-        self._subscription_response_queue = asyncio.Queue(
+        self._subscription_response_queue = TaskReliantQueue(
             maxsize=self._subscription_response_queue.maxsize
         )

web3/providers/websocket/websocket_v2.py

@@ -22,12 +22,8 @@ from websockets.exceptions import (
     WebSocketException,
 )
 
-from web3._utils.caching import (
-    generate_cache_key,
-)
 from web3.exceptions import (
     ProviderConnectionError,
-    TimeExhausted,
     Web3ValidationError,
 )
 from web3.providers.persistent import (
@@ -35,7 +31,6 @@ from web3.providers.persistent import (
 )
 from web3.types import (
     RPCEndpoint,
-    RPCId,
     RPCResponse,
 )
 
@@ -59,7 +54,6 @@ def get_default_endpoint() -> URI:
 class WebsocketProviderV2(PersistentConnectionProvider):
     logger = logging.getLogger("web3.providers.WebsocketProviderV2")
     is_async: bool = True
-    _max_connection_retries: int = 5
 
     def __init__(
         self,
@@ -69,16 +63,16 @@ class WebsocketProviderV2(PersistentConnectionProvider):
         # `PersistentConnectionProvider` kwargs can be passed through
         **kwargs: Any,
     ) -> None:
-        self.endpoint_uri = URI(endpoint_uri)
-        if self.endpoint_uri is None:
-            self.endpoint_uri = get_default_endpoint()
+        self.endpoint_uri = (
+            URI(endpoint_uri) if endpoint_uri is not None else get_default_endpoint()
+        )
 
         if not any(
             self.endpoint_uri.startswith(prefix)
             for prefix in VALID_WEBSOCKET_URI_PREFIXES
         ):
             raise Web3ValidationError(
-                "Websocket endpoint uri must begin with 'ws://' or 'wss://': "
+                "WebSocket endpoint uri must begin with 'ws://' or 'wss://': "
                 f"{self.endpoint_uri}"
             )
 
@@ -93,12 +87,13 @@ class WebsocketProviderV2(PersistentConnectionProvider):
                 )
 
         self.websocket_kwargs = merge(DEFAULT_WEBSOCKET_KWARGS, websocket_kwargs or {})
-        self.silence_listener_task_exceptions = silence_listener_task_exceptions
 
-        super().__init__(**kwargs)
+        super().__init__(
+            silence_listener_task_exceptions=silence_listener_task_exceptions, **kwargs
+        )
 
     def __str__(self) -> str:
-        return f"Websocket connection: {self.endpoint_uri}"
+        return f"WebSocket connection: {self.endpoint_uri}"
 
     async def is_connected(self, show_traceback: bool = False) -> bool:
         if not self._ws:
@@ -115,47 +110,13 @@ class WebsocketProviderV2(PersistentConnectionProvider):
                 ) from e
             return False
 
-    async def connect(self) -> None:
-        _connection_attempts = 0
-        _backoff_rate_change = 1.75
-        _backoff_time = 1.75
-
-        while _connection_attempts != self._max_connection_retries:
-            try:
-                _connection_attempts += 1
-                self._ws = await connect(self.endpoint_uri, **self.websocket_kwargs)
-                self._message_listener_task = asyncio.create_task(
-                    self._ws_message_listener()
-                )
-                break
-            except WebSocketException as e:
-                if _connection_attempts == self._max_connection_retries:
-                    raise ProviderConnectionError(
-                        f"Could not connect to endpoint: {self.endpoint_uri}. "
-                        f"Retries exceeded max of {self._max_connection_retries}."
-                    ) from e
-                self.logger.info(
-                    f"Could not connect to endpoint: {self.endpoint_uri}. Retrying in "
-                    f"{round(_backoff_time, 1)} seconds.",
-                    exc_info=True,
-                )
-                await asyncio.sleep(_backoff_time)
-                _backoff_time *= _backoff_rate_change
+    async def _provider_specific_connect(self) -> None:
+        self._ws = await connect(self.endpoint_uri, **self.websocket_kwargs)
 
-    async def disconnect(self) -> None:
+    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
-            self.logger.debug(
-                f'Successfully disconnected from endpoint: "{self.endpoint_uri}'
-            )
-
-        try:
-            self._message_listener_task.cancel()
-            await self._message_listener_task
-        except (asyncio.CancelledError, StopAsyncIteration):
-            pass
-        self._request_processor.clear_caches()
 
     async def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
         request_data = self.encode_rpc_request(method, params)
@@ -174,69 +135,12 @@ class WebsocketProviderV2(PersistentConnectionProvider):
 
         return response
 
-    async def _get_response_for_request_id(self, request_id: RPCId) -> RPCResponse:
-        async def _match_response_id_to_request_id() -> RPCResponse:
-            request_cache_key = generate_cache_key(request_id)
-
-            while True:
-                # sleep(0) here seems to be the most efficient way to yield control
-                # back to the event loop while waiting for the response to be in the
-                # queue.
-                await asyncio.sleep(0)
-
-                if request_cache_key in self._request_processor._request_response_cache:
-                    self.logger.debug(
-                        f"Popping response for id {request_id} from cache."
-                    )
-                    popped_response = await self._request_processor.pop_raw_response(
-                        cache_key=request_cache_key,
-                    )
-                    return popped_response
-
-        try:
-            # Add the request timeout around the while loop that checks the request
-            # cache and tried to recv(). If the request is neither in the cache, nor
-            # received within the request_timeout, raise ``TimeExhausted``.
-            return await asyncio.wait_for(
-                _match_response_id_to_request_id(), self.request_timeout
-            )
-        except asyncio.TimeoutError:
-            raise TimeExhausted(
-                f"Timed out waiting for response with request id `{request_id}` after "
-                f"{self.request_timeout} second(s). This may be due to the provider "
-                "not returning a response with the same id that was sent in the "
-                "request or an exception raised during the request was caught and "
-                "allowed to continue."
-            )
-
-    async def _ws_message_listener(self) -> None:
-        self.logger.info(
-            "Websocket listener background task started. Storing all messages in "
-            "appropriate request processor queues / caches to be processed."
-        )
-        while True:
-            # 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.
+    async def _provider_specific_message_listener(self) -> None:
+        async for raw_message in self._ws:
             await asyncio.sleep(0)
 
-            try:
-                async for raw_message in self._ws:
-                    await asyncio.sleep(0)
-
-                    response = json.loads(raw_message)
-                    subscription = response.get("method") == "eth_subscription"
-                    await self._request_processor.cache_raw_response(
-                        response, subscription=subscription
-                    )
-            except Exception as e:
-                if not self.silence_listener_task_exceptions:
-                    loop = asyncio.get_event_loop()
-                    for task in asyncio.all_tasks(loop=loop):
-                        task.cancel()
-                    raise e
-
-                self.logger.error(
-                    "Exception caught in listener, error logging and keeping "
-                    "listener background task alive."
-                    f"\n    error={e.__class__.__name__}: {e}"
-                )
+            response = json.loads(raw_message)
+            subscription = response.get("method") == "eth_subscription"
+            await self._request_processor.cache_raw_response(
+                response, subscription=subscription
+            )

web3/tools/pytest_ethereum/deployer.py

@@ -27,7 +27,7 @@ class Deployer:
                 f"Expected a Package object, instead received {type(package)}."
             )
         self.package = package
-        self.strategies = {}  # type: Dict[str, Callable[[Package], Package]]
+        self.strategies: Dict[str, Callable[[Package], Package]] = {}
 
     def deploy(self, contract_type: ContractName, *args: Any, **kwargs: Any) -> Package:
         factory = self.package.get_contract_factory(contract_type)

{web3-6.18.0.dist-info → web3-6.19.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: web3
-Version: 6.18.0
+Version: 6.19.0
 Summary: web3.py
 Home-page: https://github.com/ethereum/web3.py
 Author: The Ethereum Foundation

{web3-6.18.0.dist-info → web3-6.19.0.dist-info}/RECORD

@@ -117,11 +117,11 @@ ethpm/validation/uri.py,sha256=JtNfDghEU-8yDoETIbEZnamlpFGF1fAQ-tdJQhqn7mg,4873
 web3/__init__.py,sha256=tieKn-7-iyxdwx_tI7eUGWBpSkawfI2_3pCnwh8PRP4,972
 web3/constants.py,sha256=eQLRQVMFPbgpOjjkPTMHkY-syncJuO-sPX5UrCSRjzQ,564
 web3/datastructures.py,sha256=5SuX36p-hGuiK3RwnG8yVsgROvkqzHdDKfTGSzghSy0,9234
-web3/exceptions.py,sha256=u0qTr7mS9wEmh-0jSfXNlEzJ-Sfigr4MwF6HxE7_wUw,6904
+web3/exceptions.py,sha256=3c0uRBiKvRJCSQUALYDCjjsjcyqx_XJM4_oQBXKrBrs,7390
 web3/geth.py,sha256=IXdSkRg5n8Nv6KXdY94HwEcFnixOosOHoNanvJNA5rk,13676
 web3/logs.py,sha256=ROs-mDMH_ZOecE7hfbWA5yp27G38FbLjX4lO_WtlZxQ,198
-web3/main.py,sha256=3bEGj9n4E9dr40RZO2RC0SI6yGeRDJzqHyv98-E6ICw,15893
-web3/manager.py,sha256=OO32G09QT4j5-p6x5ZxYT82Z5HMnyCm0G1PqPPPHbqA,16212
+web3/main.py,sha256=bPMEBxLfoA4VeLIeAO4V7oXXujHieBQHpDTA3eMHf_I,15854
+web3/manager.py,sha256=TI705zxN2ZEnqJoA3EwWoiYnnw9B642c9rHndIg0BtA,16643
 web3/method.py,sha256=KKtQR9YjzSWWzl_gsLX0P4JqOEJnCzhN6naM9GOQvm0,8349
 web3/module.py,sha256=hoPoBaH992SHm_DRA7yxYZTFy61RQJ7_NZTU-AkZmds,4659
 web3/net.py,sha256=Y3vPzHWVFkfHEZoJxjDOt4tp5ERmZrMuyi4ZFOLmIeA,1562
@@ -195,7 +195,7 @@ web3/_utils/module_testing/eth_module.py,sha256=JQ0XAF5GlvpHn3oeAi2DfltJdCZwHk7J
 web3/_utils/module_testing/go_ethereum_admin_module.py,sha256=_c-6SyzZkfAJ-7ySXUpw9FEr4cg-ShRdAGSAHWanCtY,3406
 web3/_utils/module_testing/go_ethereum_personal_module.py,sha256=KzYEcAs_6Ud_gbu6YMOC6HijTdNFiz-qogMCViedmY0,11536
 web3/_utils/module_testing/go_ethereum_txpool_module.py,sha256=5f8XL8-2x3keyGRaITxMQYl9oQzjgqGn8zobB-j9BPs,1176
-web3/_utils/module_testing/module_testing_utils.py,sha256=sfsIUGtVOntKHh-HBiY4FaWvsVsy9UQkCEmhaTnqQSc,5987
+web3/_utils/module_testing/module_testing_utils.py,sha256=_BV5xITzHC6HkOL3GD6bCJ-vhEsPQt2iSpY9S_SWXYo,6290
 web3/_utils/module_testing/net_module.py,sha256=ifUTC-5fTcQbwpm0X09OdD5RSPnn00T8klFeYe8tTm4,1272
 web3/_utils/module_testing/persistent_connection_provider.py,sha256=2NFjp0ZShOt_D5gmcfrc2ua57mRyeFSZpkqtPgCNUgM,16620
 web3/_utils/module_testing/web3_module.py,sha256=Y4lYglg_kbrpfwGfjekv52h4B7DaWa3uS15KGrCKL7c,9613
@@ -243,17 +243,17 @@ web3/providers/async_rpc.py,sha256=1tf72qPH8A3IW2ZJus9nORL-PfPgRtmj1YRFASVWyuM,2
 web3/providers/auto.py,sha256=-dS_-2nhg2jOA432P0w3Ul3NUIso8rTl4uGUGo0XBw0,3447
 web3/providers/base.py,sha256=qASmfdhXhD2FSk2Uk8z-8NxVL4i42uJNoUlwRDzQpgI,4187
 web3/providers/ipc.py,sha256=xFWT6cY9emTnFMuIQFrmQ0DJMQSMoQtaztD7MTTVniI,6374
-web3/providers/persistent.py,sha256=EHNmRso_-nvNLnTGF6jgmb_KRU29LgMfVU4mFt5RYBw,1668
+web3/providers/persistent.py,sha256=L9Cgs3RxcUmplo3-mnDl9U0VlzMWfXZSVMWtWMjS0bY,8376
 web3/providers/rpc.py,sha256=w3XA8lhufp_tcGCqocRwi2DDt8j3fj0hoZGk0dfF0u0,2686
 web3/providers/eth_tester/__init__.py,sha256=J6wazY3hQySsUfpFgwCXbEMo-CGEZjRo11RCg4UXKmA,83
 web3/providers/eth_tester/defaults.py,sha256=Ri_WPJT8aumxwiZXwedkJ16H_gBkLsKqanlDLfeFqM8,14803
 web3/providers/eth_tester/main.py,sha256=mI7XAqp0_lZVtVhr7HAh8noJfcxYL9qFfmxoV2jKVPo,5845
 web3/providers/eth_tester/middleware.py,sha256=LN3UZ789e5pwfBBrx9_1N2ByiEYIy6ioMpYddv1u1Zw,13944
 web3/providers/websocket/__init__.py,sha256=W5xi6NxUVaskom7k03vd2HCXSH8hXAob2ry-ULiNSUo,232
-web3/providers/websocket/request_processor.py,sha256=dlYerMlb3aA2wQ5kN2TlDyJrIsLv4MoqOU47IQtCCeU,10734
+web3/providers/websocket/request_processor.py,sha256=kir6bkAWy6CQdBpNrk_8CB8GPsjXM42SXx7IYlAngqE,11653
 web3/providers/websocket/websocket.py,sha256=-U2-CGtqpysxZoFHsa-rBeZKjSRejqQSeb5Z12SzKwk,3929
 web3/providers/websocket/websocket_connection.py,sha256=_W3i_nF9NNRdSwFGwLsDCNXrrhlhV-NvmywX8vbuWvY,1104
-web3/providers/websocket/websocket_v2.py,sha256=X_jxeF0QF9gFGP8LZM5_dA2n-6e7WIb6w-i_fOb9lcg,8698
+web3/providers/websocket/websocket_v2.py,sha256=HX-p1CATh2eA02H0vbKh33XQdahoiSp5RH8uUoXzndY,4402
 web3/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 web3/scripts/release/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 web3/scripts/release/test_package.py,sha256=DH0AryllcF4zfpWSd0NLPSQGHNoC-Qng5WYYbS5_4c8,1534
@@ -265,7 +265,7 @@ web3/tools/benchmark/reporting.py,sha256=t6XZhitwMcKjIXU6tlPEjgDmozvCSK3RoOW-0bO
 web3/tools/benchmark/utils.py,sha256=GjSofFEq3ugFtpyBlAx7n6cgZrQ5Xu4-hN_36bQBwnA,1722
 web3/tools/pytest_ethereum/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 web3/tools/pytest_ethereum/_utils.py,sha256=2rZz6L4lXmpTyXFiXWFu8AI2qX4sftzjlbdtqmaWgGE,4158
-web3/tools/pytest_ethereum/deployer.py,sha256=QZVWQpbRlHZuMqx8R7ZJIOaAU7-UyCgLBz6KPUAjsZI,1423
+web3/tools/pytest_ethereum/deployer.py,sha256=xAlBX7Mvn6csumjrCItDf8iPLfLwj2OsuAshPdnRPZI,1415
 web3/tools/pytest_ethereum/exceptions.py,sha256=5H8abL5ywZlSR0ASCR_2klPUDKjncf-7BTVgAcFraUU,380
 web3/tools/pytest_ethereum/linker.py,sha256=fnkHsX2Yhus29nnPj0bTCkWdzTUeSfvxYIamM9QcqI8,3927
 web3/tools/pytest_ethereum/plugins.py,sha256=QgC4Lm-pHIAj5IMFcmKyuWa13_mfedkSVmjuE_8Tdzc,645
@@ -275,9 +275,9 @@ web3/utils/address.py,sha256=KC_IpEbixSCuMhaW6V2QCyyJTYKYGS9c8QtI9_aH7zQ,967
 web3/utils/async_exception_handling.py,sha256=gfLuzP7Y5rc21jZVjWEYAOZUMJkJd9CmsL297UKReow,3096
 web3/utils/caching.py,sha256=PgfuXiVgPYQuS0S89-jkNOJ3L2uTRt2MkVBvzMkaAXI,1770
 web3/utils/exception_handling.py,sha256=12xkzIqMAOx0Jcm6PYL98PmWlLPKFll0p9YoLGS_ZNg,3052
-web3-6.18.0.dist-info/LICENSE,sha256=ulnXiEqqFp9VyWe8yMFdtDi70RMBJk3mpY3FKujv6l8,1090
-web3-6.18.0.dist-info/METADATA,sha256=grPGPcFqgL_8ihZCBlqeP_FL4rwoCPOBTHgSE_R2dqQ,4522
-web3-6.18.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-web3-6.18.0.dist-info/entry_points.txt,sha256=2qjzGxFUlYBzoP68fcB3AJyMRunWI70uBoxNp17Brb0,64
-web3-6.18.0.dist-info/top_level.txt,sha256=5lRZg30BFUrz8eUK60C7OAjNT3FI4YsGmA-vZ0WIOik,15
-web3-6.18.0.dist-info/RECORD,,
+web3-6.19.0.dist-info/LICENSE,sha256=ulnXiEqqFp9VyWe8yMFdtDi70RMBJk3mpY3FKujv6l8,1090
+web3-6.19.0.dist-info/METADATA,sha256=x0ZZ5THuZWBU5i5JndaNJpnoYMemRUafzsdYa5bVOaA,4522
+web3-6.19.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+web3-6.19.0.dist-info/entry_points.txt,sha256=2qjzGxFUlYBzoP68fcB3AJyMRunWI70uBoxNp17Brb0,64
+web3-6.19.0.dist-info/top_level.txt,sha256=5lRZg30BFUrz8eUK60C7OAjNT3FI4YsGmA-vZ0WIOik,15
+web3-6.19.0.dist-info/RECORD,,