Make AsyncWeb3 Generic (ethereum#3761)

* fix: Made function params Optional, as None is the default input

* feat: Made AsyncWeb3 class Generic to fix type errors when importing Web3

* refactor: remove unnecessary noqa: E501 uses

* fix: remove `Optional` where it isn't optional

* fix: Use `Optional` where appropriate

* chore: add newsfragment for ethereum#3761

* fix: Removed  where it isn't optional

* Remove unnecessary changes

---------

Co-authored-by: fselmo <[email protected]>
Co-authored-by: kclowes <[email protected]>

Author: 3 people

faster_ens/async_ens.py

@@ -73,7 +73,9 @@
         AsyncContract,
         AsyncContractFunction,
     )
-    from faster_web3.main import AsyncWeb3  # noqa: F401
+    from faster_web3.main import (  # noqa: F401
+        AsyncWeb3,
+    )
     from faster_web3.middleware.base import (  # noqa: F401
         Middleware,
     )
@@ -97,7 +99,7 @@ class AsyncENS(BaseENS):
     """
 
     # mypy types
-    w3: "AsyncWeb3"
+    w3: "AsyncWeb3[Any]"
 
     def __init__(
         self,
@@ -124,7 +126,11 @@ def __init__(
         )
 
     @classmethod
-    def from_web3(cls, w3: "AsyncWeb3", addr: Optional[ChecksumAddress] = None) -> "AsyncENS":
+    def from_web3(
+        cls,
+        w3: "AsyncWeb3[Any]",
+        addr: Optional[ChecksumAddress] = None,
+    ) -> "AsyncENS":
         """
         Generate an AsyncENS instance with web3
 

faster_ens/base_ens.py

@@ -41,7 +41,7 @@
 
 @mypyc_attr(allow_interpreted_subclasses=True)
 class BaseENS:
-    w3: Union["AsyncWeb3", "Web3"]
+    w3: Union["AsyncWeb3[Any]", "Web3"]
     ens: Optional[Union["Contract", "AsyncContract"]] = None
     _resolver_contract: Optional[Union[Type["Contract"], Type["AsyncContract"]]] = None
     _reverse_resolver_contract: Optional[Union[Type["Contract"], Type["AsyncContract"]]] = None

faster_ens/utils.py

@@ -300,7 +300,7 @@ def is_valid_ens_name(ens_name: str) -> bool:
 def init_async_web3(
     provider: Optional["AsyncBaseProvider"] = None,
     middleware: Optional[Sequence[Tuple["Middleware", str]]] = (),
-) -> "AsyncWeb3":
+) -> "AsyncWeb3[Any]":
     from faster_web3 import (
         AsyncWeb3 as AsyncWeb3Main,
     )

faster_web3/_utils/abi.py

@@ -858,7 +858,7 @@ def _named_subtree(
 
 def recursive_dict_to_namedtuple(data: Dict[str, Any]) -> Tuple[Any, ...]:
     def _dict_to_namedtuple(
-        value: Union[Dict[str, Any], List[Any]]
+        value: Union[Dict[str, Any], List[Any]],
     ) -> Union[Tuple[Any, ...], List[Any]]:
         if not isinstance(value, dict):
             return value
@@ -870,7 +870,7 @@ def _dict_to_namedtuple(
 
 
 def abi_decoded_namedtuple_factory(
-    fields: Tuple[Any, ...]
+    fields: Tuple[Any, ...],
 ) -> Callable[..., Tuple[Any, ...]]:
     class ABIDecodedNamedTuple(namedtuple("ABIDecodedNamedTuple", fields, rename=True)):  # type: ignore # noqa: E501
         def __new__(self, args: Any) -> "ABIDecodedNamedTuple":
@@ -883,9 +883,9 @@ def __new__(self, args: Any) -> "ABIDecodedNamedTuple":
 
 
 async def async_data_tree_map(
-    async_w3: "AsyncWeb3",
+    async_w3: "AsyncWeb3[Any]",
     func: Callable[
-        ["AsyncWeb3", TypeStr, Any], Coroutine[Any, Any, Tuple[TypeStr, Any]]
+        ["AsyncWeb3[Any]", TypeStr, Any], Coroutine[Any, Any, Tuple[TypeStr, Any]]
     ],
     data_tree: Any,
 ) -> "ABITypedData":
@@ -908,7 +908,7 @@ async def async_map_to_typed_data(elements: Any) -> "ABITypedData":
 
 @reject_recursive_repeats
 async def async_recursive_map(
-    async_w3: "AsyncWeb3",
+    async_w3: "AsyncWeb3[Any]",
     func: Callable[[Any], Coroutine[Any, Any, TReturn]],
     data: Any,
 ) -> TReturn:

faster_web3/_utils/async_transactions.py

@@ -1,5 +1,6 @@
 from typing import (
     TYPE_CHECKING,
+    Any,
     Dict,
     Final,
     Optional,
@@ -47,13 +48,13 @@
 
 # unused vars present in these funcs because they all need to have the same signature
 async def _estimate_gas(
-    async_w3: "AsyncWeb3", tx: TxParams, _defaults: Dict[str, Union[bytes, int]]
+    async_w3: "AsyncWeb3[Any]", tx: TxParams, _defaults: Dict[str, Union[bytes, int]]
 ) -> int:
     return await async_w3.eth.estimate_gas(tx)
 
 
 async def _max_fee_per_gas(
-    async_w3: "AsyncWeb3", tx: TxParams, defaults: Dict[str, Union[bytes, int]]
+    async_w3: "AsyncWeb3[Any]", tx: TxParams, defaults: Dict[str, Union[bytes, int]]
 ) -> Wei:
     block = await async_w3.eth.get_block("latest")
     max_priority_fee = tx.get(
@@ -63,13 +64,13 @@ async def _max_fee_per_gas(
 
 
 async def _max_priority_fee_gas(
-    async_w3: "AsyncWeb3", _tx: TxParams, _defaults: Dict[str, Union[bytes, int]]
+    async_w3: "AsyncWeb3[Any]", _tx: TxParams, _defaults: Dict[str, Union[bytes, int]]
 ) -> Wei:
     return await async_w3.eth.max_priority_fee
 
 
 async def _chain_id(
-    async_w3: "AsyncWeb3", _tx: TxParams, _defaults: Dict[str, Union[bytes, int]]
+    async_w3: "AsyncWeb3[Any]", _tx: TxParams, _defaults: Dict[str, Union[bytes, int]]
 ) -> int:
     return await async_w3.eth.chain_id
 
@@ -93,7 +94,7 @@ async def get_block_gas_limit(
 
 
 async def get_buffered_gas_estimate(
-    async_w3: "AsyncWeb3", transaction: TxParams, gas_buffer: int = 100000
+    async_w3: "AsyncWeb3[Any]", transaction: TxParams, gas_buffer: int = 100000
 ) -> int:
     gas_estimate_transaction = cast(TxParams, dict(**transaction))
 
@@ -111,7 +112,9 @@ async def get_buffered_gas_estimate(
     return min(gas_limit, gas_estimate + gas_buffer)
 
 
-async def async_fill_nonce(async_w3: "AsyncWeb3", transaction: TxParams) -> TxParams:
+async def async_fill_nonce(
+    async_w3: "AsyncWeb3[Any]", transaction: TxParams
+) -> TxParams:
     if "from" in transaction and "nonce" not in transaction:
         tx_count = await async_w3.eth.get_transaction_count(
             cast(ChecksumAddress, transaction["from"]),
@@ -122,7 +125,7 @@ async def async_fill_nonce(async_w3: "AsyncWeb3", transaction: TxParams) -> TxPa
 
 
 async def async_fill_transaction_defaults(
-    async_w3: "AsyncWeb3", transaction: TxParams
+    async_w3: "AsyncWeb3[Any]", transaction: TxParams
 ) -> TxParams:
     """
     If async_w3 is None, fill as much as possible while offline
@@ -166,7 +169,7 @@ async def async_fill_transaction_defaults(
 
 
 async def async_get_required_transaction(
-    async_w3: "AsyncWeb3", transaction_hash: _Hash32
+    async_w3: "AsyncWeb3[Any]", transaction_hash: _Hash32
 ) -> TxData:
     current_transaction = await async_w3.eth.get_transaction(transaction_hash)
     if not current_transaction:
@@ -177,7 +180,7 @@ async def async_get_required_transaction(
 
 
 async def async_replace_transaction(
-    async_w3: "AsyncWeb3", current_transaction: TxData, new_transaction: TxParams
+    async_w3: "AsyncWeb3[Any]", current_transaction: TxData, new_transaction: TxParams
 ) -> HexBytes:
     new_transaction = prepare_replacement_transaction(
         async_w3, current_transaction, new_transaction

faster_web3/_utils/batching.py

@@ -75,7 +75,7 @@
 
 @final
 class RequestBatcher(Generic[TFunc]):
-    def __init__(self, web3: Union["AsyncWeb3", "Web3"]) -> None:
+    def __init__(self, web3: Union["AsyncWeb3[Any]", "Web3"]) -> None:
         self.web3: Final = web3
         self._requests_info: Final[List[BatchRequestInformation]] = []
         self._async_requests_info: Final[

faster_web3/_utils/caching/caching_utils.py

@@ -254,7 +254,7 @@ 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
@@ -415,7 +415,7 @@ def async_handle_recv_caching(
     func: Callable[
         ["PersistentConnectionProvider", "RPCRequest"],
         Coroutine[Any, Any, "RPCResponse"],
-    ]
+    ],
 ) -> Callable[..., Coroutine[Any, Any, "RPCResponse"]]:
     async def wrapper(
         provider: "PersistentConnectionProvider",

faster_web3/_utils/contracts.py

@@ -122,7 +122,7 @@ def find_matching_event_abi(
 
 
 def encode_abi(
-    w3: Union["AsyncWeb3", "Web3"],
+    w3: Union["AsyncWeb3[Any]", "Web3"],
     abi: ABIElement,
     arguments: Sequence[Any],
     data: Optional[Union[HexStr, HexBytes]] = None,
@@ -168,7 +168,7 @@ def encode_abi(
 
 def prepare_transaction(
     address: Union[ChecksumAddress, Address, None],
-    w3: Union["AsyncWeb3", "Web3"],
+    w3: Union["AsyncWeb3[Any]", "Web3"],
     abi_element_identifier: ABIElementIdentifier,
     contract_abi: Optional[ABI] = None,
     abi_callable: Optional[ABICallable] = None,
@@ -232,7 +232,7 @@ def prepare_transaction(
 
 
 def encode_transaction_data(
-    w3: Union["AsyncWeb3", "Web3"],
+    w3: Union["AsyncWeb3[Any]", "Web3"],
     abi_element_identifier: ABIElementIdentifier,
     contract_abi: Optional[ABI] = None,
     abi_callable: Optional[ABICallable] = None,
@@ -361,7 +361,7 @@ def parse_block_identifier_int(w3: "Web3", block_identifier_int: int) -> BlockNu
 
 
 async def async_parse_block_identifier(
-    async_w3: "AsyncWeb3", block_identifier: BlockIdentifier
+    async_w3: "AsyncWeb3[Any]", block_identifier: BlockIdentifier
 ) -> BlockIdentifier:
     if block_identifier is None:
         return async_w3.eth.default_block
@@ -379,7 +379,7 @@ async def async_parse_block_identifier(
 
 
 async def async_parse_block_identifier_int(
-    async_w3: "AsyncWeb3", block_identifier_int: int
+    async_w3: "AsyncWeb3[Any]", block_identifier_int: int
 ) -> BlockNumber:
     if block_identifier_int >= 0:
         block_num = block_identifier_int

faster_web3/_utils/ens.py

@@ -78,7 +78,7 @@ async def address(self, name: str) -> ChecksumAddress:
 
 @contextmanager
 def ens_addresses(
-    w3: Union["Web3", "AsyncWeb3"], name_addr_pairs: Dict[str, ChecksumAddress]
+    w3: Union["Web3", "AsyncWeb3[Any]"], name_addr_pairs: Dict[str, ChecksumAddress]
 ) -> Iterator[None]:
     original_ens = w3.ens
     if w3.provider.is_async:

faster_web3/_utils/events.py

@@ -454,7 +454,7 @@ def deploy(self, w3: "Web3") -> "LogFilter":
 
 
 class AsyncEventFilterBuilder(BaseEventFilterBuilder):
-    async def deploy(self, async_w3: "AsyncWeb3") -> "AsyncLogFilter":
+    async def deploy(self, async_w3: "AsyncWeb3[Any]") -> "AsyncLogFilter":
         if not isinstance(async_w3, faster_web3.AsyncWeb3):
             raise Web3ValueError(f"Invalid web3 argument: got: {async_w3!r}")