web3 7.6.1__py3-none-any.whl → 7.8.0__py3-none-any.whl

ens/async_ens.py

@@ -152,12 +152,12 @@ class AsyncENS(BaseENS):
         :param int coin_type: if provided, look up the address for this coin type
         :raises InvalidName: if `name` has invalid syntax
         """
-        r = await self.resolver(name)
         if coin_type is None:
             # don't validate `addr(bytes32)` interface id since extended resolvers
             # can implement a "resolve" function as of ENSIP-10
             return cast(ChecksumAddress, await self._resolve(name, "addr"))
         else:
+            r = await self.resolver(name)
             await _async_validate_resolver_and_interface_id(
                 name, r, ENS_MULTICHAIN_ADDRESS_INTERFACE_ID, "addr(bytes32,uint256)"
             )

ens/ens.py

@@ -154,12 +154,12 @@ class ENS(BaseENS):
         :raises UnsupportedFunction: if the resolver does not support the ``addr()``
                 function
         """
-        r = self.resolver(name)
         if coin_type is None:
             # don't validate `addr(bytes32)` interface id since extended resolvers
             # can implement a "resolve" function as of ENSIP-10
             return cast(ChecksumAddress, self._resolve(name, "addr"))
         else:
+            r = self.resolver(name)
             _validate_resolver_and_interface_id(
                 name, r, ENS_MULTICHAIN_ADDRESS_INTERFACE_ID, "addr(bytes32,uint256)"
             )

web3/_utils/caching/caching_utils.py

@@ -64,10 +64,12 @@ if TYPE_CHECKING:
     from web3.providers import (  # noqa: F401
         AsyncBaseProvider,
         BaseProvider,
+        PersistentConnectionProvider,
     )
     from web3.types import (  # noqa: F401
         AsyncMakeRequestFn,
         MakeRequestFn,
+        RPCRequest,
         RPCResponse,
     )
 
@@ -367,3 +369,65 @@ def async_handle_request_caching(
     # save a reference to the decorator on the wrapped function
     wrapper._decorator = async_handle_request_caching  # type: ignore
     return wrapper
+
+
+def async_handle_send_caching(
+    func: Callable[
+        [ASYNC_PROVIDER_TYPE, RPCEndpoint, Any],
+        Coroutine[Any, Any, "RPCRequest"],
+    ],
+) -> Callable[..., Coroutine[Any, Any, "RPCRequest"]]:
+    async def wrapper(
+        provider: ASYNC_PROVIDER_TYPE, method: RPCEndpoint, params: Any
+    ) -> "RPCRequest":
+        if is_cacheable_request(provider, method, params):
+            request_cache = provider._request_cache
+            cache_key = generate_cache_key(
+                f"{threading.get_ident()}:{(method, params)}"
+            )
+            cached_response = request_cache.get_cache_entry(cache_key)
+            if cached_response is not None:
+                # The request data isn't used, this just prevents a cached request from
+                # being sent - return an empty request object
+                return {"id": -1, "method": RPCEndpoint(""), "params": []}
+        return await func(provider, method, params)
+
+    # save a reference to the decorator on the wrapped function
+    wrapper._decorator = async_handle_send_caching  # type: ignore
+    return wrapper
+
+
+def async_handle_recv_caching(
+    func: Callable[
+        ["PersistentConnectionProvider", "RPCRequest"],
+        Coroutine[Any, Any, "RPCResponse"],
+    ]
+) -> Callable[..., Coroutine[Any, Any, "RPCResponse"]]:
+    async def wrapper(
+        provider: "PersistentConnectionProvider",
+        rpc_request: "RPCRequest",
+    ) -> "RPCResponse":
+        method = rpc_request["method"]
+        params = rpc_request["params"]
+        if is_cacheable_request(provider, method, params):
+            request_cache = provider._request_cache
+            cache_key = generate_cache_key(
+                f"{threading.get_ident()}:{(method, params)}"
+            )
+            cache_result = request_cache.get_cache_entry(cache_key)
+            if cache_result is not None:
+                return cache_result
+            else:
+                response = await func(provider, rpc_request)
+                if await _async_should_cache_response(
+                    provider, method, params, response
+                ):
+                    async with provider._request_cache_lock:
+                        request_cache.cache(cache_key, response)
+                return response
+        else:
+            return await func(provider, rpc_request)
+
+    # save a reference to the decorator on the wrapped function
+    wrapper._decorator = async_handle_recv_caching  # type: ignore
+    return wrapper

web3/_utils/caching/request_caching_validation.py

@@ -19,6 +19,7 @@ if TYPE_CHECKING:
     from web3.providers import (  # noqa: F401
         AsyncBaseProvider,
         BaseProvider,
+        PersistentConnectionProvider,
     )
 
 UNCACHEABLE_BLOCK_IDS = {"finalized", "safe", "latest", "pending"}

web3/_utils/events.py

@@ -325,7 +325,7 @@ normalize_topic_list = compose(
 
 
 def is_indexed(arg: Any) -> bool:
-    if isinstance(arg, TopicArgumentFilter) is True:
+    if isinstance(arg, TopicArgumentFilter):
         return True
     return False
 

web3/_utils/http_session_manager.py

@@ -18,6 +18,7 @@ from aiohttp import (
     ClientResponse,
     ClientSession,
     ClientTimeout,
+    TCPConnector,
 )
 from eth_typing import (
     URI,
@@ -119,11 +120,19 @@ class HTTPSessionManager:
     def get_response_from_post_request(
         self, endpoint_uri: URI, *args: Any, **kwargs: Any
     ) -> requests.Response:
+        kwargs.setdefault("timeout", DEFAULT_HTTP_TIMEOUT)
         session = self.cache_and_return_session(
             endpoint_uri, request_timeout=kwargs["timeout"]
         )
         return session.post(endpoint_uri, *args, **kwargs)
 
+    def json_make_post_request(
+        self, endpoint_uri: URI, *args: Any, **kwargs: Any
+    ) -> Dict[str, Any]:
+        response = self.get_response_from_post_request(endpoint_uri, *args, **kwargs)
+        response.raise_for_status()
+        return response.json()
+
     def make_post_request(
         self, endpoint_uri: URI, data: Union[bytes, Dict[str, Any]], **kwargs: Any
     ) -> bytes:
@@ -142,8 +151,9 @@ class HTTPSessionManager:
             else:
                 return response.content
 
+    @staticmethod
     def _handle_streaming_response(
-        self, response: requests.Response, start: float, timeout: float
+        response: requests.Response, start: float, timeout: float
     ) -> bytes:
         response_body = b""
         for data in response.iter_content():
@@ -174,7 +184,12 @@ class HTTPSessionManager:
         async with async_lock(self.session_pool, self._lock):
             if cache_key not in self.session_cache:
                 if session is None:
-                    session = ClientSession(raise_for_status=True)
+                    session = ClientSession(
+                        raise_for_status=True,
+                        connector=TCPConnector(
+                            force_close=True, enable_cleanup_closed=True
+                        ),
+                    )
 
                 cached_session, evicted_items = self.session_cache.cache(
                     cache_key, session
@@ -213,7 +228,12 @@ class HTTPSessionManager:
                     )
 
                     # replace stale session with a new session at the cache key
-                    _session = ClientSession(raise_for_status=True)
+                    _session = ClientSession(
+                        raise_for_status=True,
+                        connector=TCPConnector(
+                            force_close=True, enable_cleanup_closed=True
+                        ),
+                    )
                     cached_session, evicted_items = self.session_cache.cache(
                         cache_key, _session
                     )
@@ -278,6 +298,15 @@ class HTTPSessionManager:
         response = await session.post(endpoint_uri, *args, **kwargs)
         return response
 
+    async def async_json_make_post_request(
+        self, endpoint_uri: URI, *args: Any, **kwargs: Any
+    ) -> Dict[str, Any]:
+        response = await self.async_get_response_from_post_request(
+            endpoint_uri, *args, **kwargs
+        )
+        response.raise_for_status()
+        return await response.json()
+
     async def async_make_post_request(
         self, endpoint_uri: URI, data: Union[bytes, Dict[str, Any]], **kwargs: Any
     ) -> bytes:

web3/_utils/module_testing/eth_module.py

@@ -58,7 +58,6 @@ from web3._utils.module_testing.module_testing_utils import (
     assert_contains_log,
     async_mock_offchain_lookup_request_response,
     flaky_geth_dev_mining,
-    flaky_with_xfail_on_exception,
     mock_offchain_lookup_request_response,
 )
 from web3._utils.module_testing.utils import (
@@ -77,7 +76,6 @@ from web3.exceptions import (
     MultipleFailedRequests,
     NameNotFound,
     OffchainLookup,
-    RequestTimedOut,
     TimeExhausted,
     TooManyRequests,
     TransactionNotFound,
@@ -1991,9 +1989,8 @@ class AsyncEthModuleTest:
         # Test with None overflowing
         filter_params: FilterParams = {
             "fromBlock": BlockNumber(0),
-            "topics": [None, None, None],
+            "topics": [None, None, None, None],
         }
-
         result = await async_w3.eth.get_logs(filter_params)
         assert len(result) == 0
 
@@ -2391,10 +2388,7 @@ class AsyncEthModuleTest:
         with pytest.raises(Web3ValueError):
             await async_w3.eth.replace_transaction(txn_hash, txn_params)
 
-    @flaky_with_xfail_on_exception(
-        reason="Very flaky on CI runs, hard to reproduce locally.",
-        exception=RequestTimedOut,
-    )
+    @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_replace_transaction_gas_price_defaulting_minimum(
         self, async_w3: "AsyncWeb3", async_keyfile_account_address: ChecksumAddress
@@ -2418,10 +2412,7 @@ class AsyncEthModuleTest:
             gas_price * 1.125
         )  # minimum gas price
 
-    @flaky_with_xfail_on_exception(
-        reason="Very flaky on CI runs, hard to reproduce locally.",
-        exception=RequestTimedOut,
-    )
+    @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_replace_transaction_gas_price_defaulting_strategy_higher(
         self, async_w3: "AsyncWeb3", async_keyfile_account_address: ChecksumAddress
@@ -2437,7 +2428,7 @@ class AsyncEthModuleTest:
 
         two_gwei_in_wei = async_w3.to_wei(2, "gwei")
 
-        def higher_gas_price_strategy(async_w3: "AsyncWeb3", txn: TxParams) -> Wei:
+        def higher_gas_price_strategy(_async_w3: "AsyncWeb3", _txn: TxParams) -> Wei:
             return two_gwei_in_wei
 
         async_w3.eth.set_gas_price_strategy(higher_gas_price_strategy)
@@ -2450,16 +2441,12 @@ class AsyncEthModuleTest:
         )  # Strategy provides higher gas price
         async_w3.eth.set_gas_price_strategy(None)  # reset strategy
 
-    @flaky_with_xfail_on_exception(
-        reason="Very flaky on CI runs, hard to reproduce locally.",
-        exception=RequestTimedOut,
-    )
+    @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_replace_transaction_gas_price_defaulting_strategy_lower(
         self, async_w3: "AsyncWeb3", async_keyfile_account_address: ChecksumAddress
     ) -> None:
         gas_price = async_w3.to_wei(2, "gwei")
-
         txn_params: TxParams = {
             "from": async_keyfile_account_address,
             "to": async_keyfile_account_address,

web3/_utils/module_testing/module_testing_utils.py

@@ -1,17 +1,12 @@
 import asyncio
-import functools
-import pytest
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
     Collection,
     Dict,
     Generator,
     Literal,
     Sequence,
-    Tuple,
-    Type,
     Union,
 )
 
@@ -63,50 +58,13 @@ due to timing of the test running as a block is mined.
 flaky_geth_dev_mining = flaky(max_runs=3, min_passes=1)
 
 
-def flaky_with_xfail_on_exception(
-    reason: str,
-    exception: Union[Type[Exception], Tuple[Type[Exception], ...]],
-    max_runs: int = 3,
-    min_passes: int = 1,
-) -> Callable[[Any], Any]:
-    """
-    Some tests inconsistently fail hard with a particular exception and retrying
-    these tests often times does not get them "unstuck". If we've exhausted all flaky
-    retries and this expected exception is raised, `xfail` the test with the given
-    reason.
-    """
-    runs = max_runs
-
-    def decorator(func: Any) -> Any:
-        @flaky(max_runs=max_runs, min_passes=min_passes)
-        @functools.wraps(func)
-        async def wrapper(self: Any, *args: Any, **kwargs: Any) -> Any:
-            nonlocal runs
-            try:
-                return await func(self, *args, **kwargs)
-            except exception:
-                # xfail the test only if the exception is raised and we have exhausted
-                # all flaky retries
-                if runs == 1:
-                    pytest.xfail(reason)
-                runs -= 1
-                pytest.fail(f"xfailed but {runs} run(s) remaining with flaky...")
-            except Exception as e:
-                # let flaky handle it
-                raise e
-
-        return wrapper
-
-    return decorator
-
-
 def assert_contains_log(
     result: Sequence[LogReceipt],
     block_with_txn_with_log: BlockData,
     emitter_contract_address: ChecksumAddress,
     txn_hash_with_log: HexStr,
 ) -> None:
-    assert len(result) == 1
+    assert len(result) > 0
     log_entry = result[0]
     assert log_entry["blockNumber"] == block_with_txn_with_log["number"]
     assert log_entry["blockHash"] == block_with_txn_with_log["hash"]