Remove caching decorator from base providers; fix typing:

- Base providers don't implement ``make_request`` and so can't cache
  requests. Remove the request caching decorator from the base provider
  classes.

- Fix typing in the request caching utils, which should now be tighter,
  expecting an ``RPCEndpoint`` instead of a generic ``str``.

Author: fselmo

web3/_utils/caching/caching_utils.py

@@ -53,6 +53,9 @@
 from web3.exceptions import (
     Web3TypeError,
 )
+from web3.types import (
+    RPCEndpoint,
+)
 from web3.utils import (
     RequestCacheValidationThreshold,
 )
@@ -65,7 +68,6 @@
     from web3.types import (  # noqa: F401
         AsyncMakeRequestFn,
         MakeRequestFn,
-        RPCEndpoint,
         RPCResponse,
     )
 
@@ -93,7 +95,7 @@ def generate_cache_key(value: Any) -> str:
 class RequestInformation:
     def __init__(
         self,
-        method: "RPCEndpoint",
+        method: RPCEndpoint,
         params: Any,
         response_formatters: Tuple[
             Union[Dict[str, Callable[..., Any]], Callable[..., Any]],
@@ -133,7 +135,7 @@ def __init__(
 
 def is_cacheable_request(
     provider: Union[ASYNC_PROVIDER_TYPE, SYNC_PROVIDER_TYPE],
-    method: "RPCEndpoint",
+    method: RPCEndpoint,
     params: Any,
 ) -> bool:
     if not (provider.cache_allowed_requests and method in provider.cacheable_requests):
@@ -173,7 +175,7 @@ def is_cacheable_request(
 }
 
 INTERNAL_VALIDATION_MAP: Dict[
-    "RPCEndpoint",
+    RPCEndpoint,
     Callable[
         [SYNC_PROVIDER_TYPE, Sequence[Any], Dict[str, Any]],
         bool,
@@ -197,7 +199,9 @@ def set_threshold_if_empty(provider: SYNC_PROVIDER_TYPE) -> None:
         try:
             # turn off momentarily to avoid recursion
             provider.cache_allowed_requests = False
-            chain_id_result = provider.make_request("eth_chainId", [])["result"]
+            chain_id_result = provider.make_request(RPCEndpoint("eth_chainId"), [])[
+                "result"
+            ]
             chain_id = int(chain_id_result, 16)
 
             if current_threshold is empty:
@@ -214,7 +218,7 @@ def set_threshold_if_empty(provider: SYNC_PROVIDER_TYPE) -> None:
 
 def _should_cache_response(
     provider: SYNC_PROVIDER_TYPE,
-    method: "RPCEndpoint",
+    method: RPCEndpoint,
     params: Sequence[Any],
     response: "RPCResponse",
 ) -> bool:
@@ -232,10 +236,10 @@ def _should_cache_response(
 
 
 def handle_request_caching(
-    func: Callable[[SYNC_PROVIDER_TYPE, "RPCEndpoint", Any], "RPCResponse"]
+    func: Callable[[SYNC_PROVIDER_TYPE, RPCEndpoint, Any], "RPCResponse"]
 ) -> Callable[..., "RPCResponse"]:
     def wrapper(
-        provider: SYNC_PROVIDER_TYPE, method: "RPCEndpoint", params: Any
+        provider: SYNC_PROVIDER_TYPE, method: RPCEndpoint, params: Any
     ) -> "RPCResponse":
         if is_cacheable_request(provider, method, params):
             request_cache = provider._request_cache
@@ -266,7 +270,7 @@ def wrapper(
     Union[bool, Coroutine[Any, Any, bool]],
 ]
 
-ASYNC_INTERNAL_VALIDATION_MAP: Dict["RPCEndpoint", ASYNC_VALIDATOR_TYPE] = {
+ASYNC_INTERNAL_VALIDATION_MAP: Dict[RPCEndpoint, ASYNC_VALIDATOR_TYPE] = {
     **{endpoint: always_cache_request for endpoint in ALWAYS_CACHE},
     **{
         endpoint: async_validate_from_block_id_in_params
@@ -292,7 +296,9 @@ async def async_set_threshold_if_empty(provider: ASYNC_PROVIDER_TYPE) -> None:
         try:
             # turn off momentarily to avoid recursion
             provider.cache_allowed_requests = False
-            chain_id_result = await provider.make_request("eth_chainId", [])
+            chain_id_result = await provider.make_request(
+                RPCEndpoint("eth_chainId"), []
+            )
             chain_id = int(chain_id_result["result"], 16)
 
             if current_threshold is empty:
@@ -309,7 +315,7 @@ async def async_set_threshold_if_empty(provider: ASYNC_PROVIDER_TYPE) -> None:
 
 async def _async_should_cache_response(
     provider: ASYNC_PROVIDER_TYPE,
-    method: "RPCEndpoint",
+    method: RPCEndpoint,
     params: Sequence[Any],
     response: "RPCResponse",
 ) -> bool:
@@ -333,11 +339,11 @@ async def _async_should_cache_response(
 
 def async_handle_request_caching(
     func: Callable[
-        [ASYNC_PROVIDER_TYPE, "RPCEndpoint", Any], Coroutine[Any, Any, "RPCResponse"]
+        [ASYNC_PROVIDER_TYPE, RPCEndpoint, Any], Coroutine[Any, Any, "RPCResponse"]
     ],
 ) -> Callable[..., Coroutine[Any, Any, "RPCResponse"]]:
     async def wrapper(
-        provider: ASYNC_PROVIDER_TYPE, method: "RPCEndpoint", params: Any
+        provider: ASYNC_PROVIDER_TYPE, method: RPCEndpoint, params: Any
     ) -> "RPCResponse":
         if is_cacheable_request(provider, method, params):
             request_cache = provider._request_cache

web3/_utils/caching/request_caching_validation.py

@@ -8,6 +8,9 @@
     Union,
 )
 
+from web3.types import (
+    RPCEndpoint,
+)
 from web3.utils import (
     RequestCacheValidationThreshold,
 )
@@ -50,7 +53,7 @@ def is_beyond_validation_threshold(
         if isinstance(threshold, RequestCacheValidationThreshold):
             # if mainnet and threshold is "finalized" or "safe"
             threshold_block = provider.make_request(
-                "eth_getBlockByNumber", [threshold.value, False]
+                RPCEndpoint("eth_getBlockByNumber"), [threshold.value, False]
             )["result"]
             # we should have a `blocknum` to compare against
             return blocknum <= int(threshold_block["number"], 16)
@@ -59,7 +62,7 @@ def is_beyond_validation_threshold(
                 # if validating via `blocknum` from params, we need to get the timestamp
                 # for the block with `blocknum`.
                 block = provider.make_request(
-                    "eth_getBlockByNumber", [hex(blocknum), False]
+                    RPCEndpoint("eth_getBlockByNumber"), [hex(blocknum), False]
                 )["result"]
                 block_timestamp = int(block["timestamp"], 16)
 
@@ -107,9 +110,9 @@ def validate_from_blocknum_in_result(
         if "blockNumber" in result:
             blocknum = result.get("blockNumber")
             # make an extra call to get the block values
-            block = provider.make_request("eth_getBlockByNumber", [blocknum, False])[
-                "result"
-            ]
+            block = provider.make_request(
+                RPCEndpoint("eth_getBlockByNumber"), [blocknum, False]
+            )["result"]
             return is_beyond_validation_threshold(
                 provider,
                 blocknum=int(blocknum, 16),
@@ -145,9 +148,9 @@ def validate_from_blockhash_in_params(
         provider.cache_allowed_requests = False
 
         # make an extra call to get the block number from the hash
-        block = provider.make_request("eth_getBlockByHash", [params[0], False])[
-            "result"
-        ]
+        block = provider.make_request(
+            RPCEndpoint("eth_getBlockByHash"), [params[0], False]
+        )["result"]
         return is_beyond_validation_threshold(
             provider,
             blocknum=int(block["number"], 16),
@@ -177,14 +180,14 @@ async def async_is_beyond_validation_threshold(
         if isinstance(threshold, RequestCacheValidationThreshold):
             # if mainnet and threshold is "finalized" or "safe"
             threshold_block = await provider.make_request(
-                "eth_getBlockByNumber", [threshold.value, False]
+                RPCEndpoint("eth_getBlockByNumber"), [threshold.value, False]
             )
             # we should have a `blocknum` to compare against
             return blocknum <= int(threshold_block["result"]["number"], 16)
         elif isinstance(threshold, int):
             if not block_timestamp:
                 block = await provider.make_request(
-                    "eth_getBlockByNumber", [hex(blocknum), False]
+                    RPCEndpoint("eth_getBlockByNumber"), [hex(blocknum), False]
                 )
                 block_timestamp = int(block["result"]["timestamp"], 16)
 
@@ -233,7 +236,7 @@ async def async_validate_from_blocknum_in_result(
             blocknum = result.get("blockNumber")
             # make an extra call to get the block values
             block = await provider.make_request(
-                "eth_getBlockByNumber", [blocknum, False]
+                RPCEndpoint("eth_getBlockByNumber"), [blocknum, False]
             )
             return await async_is_beyond_validation_threshold(
                 provider,
@@ -268,7 +271,9 @@ async def async_validate_from_blockhash_in_params(
         provider.cache_allowed_requests = False
 
         # make an extra call to get the block number from the hash
-        response = await provider.make_request("eth_getBlockByHash", [params[0], False])
+        response = await provider.make_request(
+            RPCEndpoint("eth_getBlockByHash"), [params[0], False]
+        )
         return await async_is_beyond_validation_threshold(
             provider,
             blocknum=int(response["result"]["number"], 16),

web3/_utils/module_testing/utils.py

@@ -113,10 +113,9 @@ def __enter__(self) -> "Self":
 
         return self
 
-    # define __exit__ with typing information
     def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
         # mypy error: Cannot assign to a method
-        self.w3.provider.make_request = self._make_request  # type: ignore[method-assign]  # noqa: E501
+        self.w3.provider.make_request = self._make_request  # type: ignore[assignment]
         # reset request func cache to re-build request_func with original make_request
         self.w3.provider._request_func_cache = (None, None)
 
@@ -175,6 +174,7 @@ def _mock_request_handler(
             return mocked_response
 
     # -- async -- #
+
     async def __aenter__(self) -> "Self":
         # mypy error: Cannot assign to a method
         self.w3.provider.make_request = self._async_mock_request_handler  # type: ignore[method-assign]  # noqa: E501
@@ -184,7 +184,7 @@ async def __aenter__(self) -> "Self":
 
     async def __aexit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
         # mypy error: Cannot assign to a method
-        self.w3.provider.make_request = self._make_request  # type: ignore[method-assign]  # noqa: E501
+        self.w3.provider.make_request = self._make_request  # type: ignore[assignment]
         # reset request func cache to re-build request_func with original make_request
         self.w3.provider._request_func_cache = (None, None)
 

web3/providers/async_base.py

@@ -22,7 +22,6 @@
 
 from web3._utils.caching import (
     CACHEABLE_REQUESTS,
-    async_handle_request_caching,
 )
 from web3._utils.empty import (
     Empty,
@@ -137,7 +136,6 @@ async def batch_request_func(
             self._batch_request_func_cache = (middleware, accumulator_fn)
         return self._batch_request_func_cache[-1]
 
-    @async_handle_request_caching
     async def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
         raise NotImplementedError("Providers must implement this method")
 

web3/providers/base.py

@@ -20,7 +20,6 @@
 
 from web3._utils.caching import (
     CACHEABLE_REQUESTS,
-    handle_request_caching,
 )
 from web3._utils.empty import (
     Empty,
@@ -109,7 +108,6 @@ def request_func(
 
         return self._request_func_cache[-1]
 
-    @handle_request_caching
     def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
         raise NotImplementedError("Providers must implement this method")