web3 7.14.1__py3-none-any.whl → 8.0.0b1__py3-none-any.whl

web3/_utils/module_testing/utils.py

@@ -1,11 +1,7 @@
-from asyncio import (
-    iscoroutinefunction,
-)
-import copy
+import inspect
 from typing import (
     TYPE_CHECKING,
     Any,
-    Dict,
     Union,
     cast,
 )
@@ -98,9 +94,9 @@ class RequestMocker:
     def __init__(
         self,
         w3: Union["AsyncWeb3[Any]", "Web3"],
-        mock_results: Dict[Union["RPCEndpoint", str], Any] = None,
-        mock_errors: Dict[Union["RPCEndpoint", str], Any] = None,
-        mock_responses: Dict[Union["RPCEndpoint", str], Any] = None,
+        mock_results: dict[Union["RPCEndpoint", str], Any] = None,
+        mock_errors: dict[Union["RPCEndpoint", str], Any] = None,
+        mock_responses: dict[Union["RPCEndpoint", str], Any] = None,
     ):
         self.w3 = w3
         self.mock_results = mock_results or {}
@@ -114,12 +110,11 @@ class RequestMocker:
                 "AsyncMakeRequestFn", "MakeRequestFn"
             ] = w3.provider.make_request
 
+        self._mock_request_counter = 1
+
     def _build_request_id(self) -> int:
-        request_id = (
-            next(copy.deepcopy(self.w3.provider.request_counter))
-            if hasattr(self.w3.provider, "request_counter")
-            else 1
-        )
+        request_id = self._mock_request_counter
+        self._mock_request_counter += 1
         return request_id
 
     def __enter__(self) -> "Self":
@@ -145,7 +140,11 @@ class RequestMocker:
 
         if all(
             method not in mock_dict
-            for mock_dict in (self.mock_errors, self.mock_results, self.mock_responses)
+            for mock_dict in (
+                self.mock_errors,
+                self.mock_results,
+                self.mock_responses,
+            )
         ):
             return self._make_request(method, params)
 
@@ -225,7 +224,7 @@ class RequestMocker:
 
             if callable(mock_return):
                 mock_return = mock_return(method, params)
-            elif iscoroutinefunction(mock_return):
+            elif inspect.iscoroutinefunction(mock_return):
                 # this is the "correct" way to mock the async make_request
                 mock_return = await mock_return(method, params)
 
@@ -240,7 +239,7 @@ class RequestMocker:
             if callable(mock_return):
                 # handle callable to make things easier since we're mocking
                 mock_return = mock_return(method, params)
-            elif iscoroutinefunction(mock_return):
+            elif inspect.iscoroutinefunction(mock_return):
                 # this is the "correct" way to mock the async make_request
                 mock_return = await mock_return(method, params)
 
@@ -250,7 +249,7 @@ class RequestMocker:
             error = self.mock_errors[method]
             if callable(error):
                 error = error(method, params)
-            elif iscoroutinefunction(error):
+            elif inspect.iscoroutinefunction(error):
                 error = await error(method, params)
             mocked_result = merge(response_dict, self._create_error_object(error))
 
@@ -266,7 +265,11 @@ class RequestMocker:
         self._make_request = cast("AsyncMakeRequestFn", self._make_request)
         if all(
             method not in mock_dict
-            for mock_dict in (self.mock_errors, self.mock_results, self.mock_responses)
+            for mock_dict in (
+                self.mock_errors,
+                self.mock_results,
+                self.mock_responses,
+            )
         ):
             return await self._make_request(method, params)
         mocked_result = await self._async_build_mock_result(method, params)
@@ -290,7 +293,11 @@ class RequestMocker:
     ) -> "RPCRequest":
         if all(
             method not in mock_dict
-            for mock_dict in (self.mock_errors, self.mock_results, self.mock_responses)
+            for mock_dict in (
+                self.mock_errors,
+                self.mock_results,
+                self.mock_responses,
+            )
         ):
             return await self._send_request(method, params)
         else:
@@ -305,7 +312,11 @@ class RequestMocker:
         request_id = rpc_request["id"]
         if all(
             method not in mock_dict
-            for mock_dict in (self.mock_errors, self.mock_results, self.mock_responses)
+            for mock_dict in (
+                self.mock_errors,
+                self.mock_results,
+                self.mock_responses,
+            )
         ):
             return await self._recv_for_request(request_id)
         mocked_result = await self._async_build_mock_result(
@@ -327,7 +338,7 @@ class RequestMocker:
             return mocked_result
 
     @staticmethod
-    def _create_error_object(error: Dict[str, Any]) -> Dict[str, Any]:
+    def _create_error_object(error: dict[str, Any]) -> dict[str, Any]:
         code = error.get("code", -32000)
         message = error.get("message", "Mocked error")
         return {"error": merge({"code": code, "message": message}, error)}

web3/_utils/normalizers.py

@@ -5,9 +5,6 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
-    Optional,
-    Tuple,
-    Union,
     cast,
 )
 
@@ -73,9 +70,9 @@ if TYPE_CHECKING:
 
 def implicitly_identity(
     to_wrap: Callable[[TypeStr, Any], Any],
-) -> Callable[[TypeStr, Any], Tuple[TypeStr, Any]]:
+) -> Callable[[TypeStr, Any], tuple[TypeStr, Any]]:
     @functools.wraps(to_wrap)
-    def wrapper(type_str: TypeStr, data: Any) -> Tuple[TypeStr, Any]:
+    def wrapper(type_str: TypeStr, data: Any) -> tuple[TypeStr, Any]:
         modified = to_wrap(type_str, data)
         if modified is None:
             return type_str, data
@@ -93,14 +90,14 @@ def implicitly_identity(
 @implicitly_identity
 def addresses_checksummed(
     type_str: TypeStr, data: Any
-) -> Tuple[TypeStr, ChecksumAddress]:
+) -> tuple[TypeStr, ChecksumAddress]:
     if type_str == "address":
         return type_str, to_checksum_address(data)
     return None
 
 
 @implicitly_identity
-def decode_abi_strings(type_str: TypeStr, data: Any) -> Tuple[TypeStr, str]:
+def decode_abi_strings(type_str: TypeStr, data: Any) -> tuple[TypeStr, str]:
     if type_str == "string":
         return type_str, codecs.decode(data, "utf8", "backslashreplace")
     return None
@@ -112,8 +109,8 @@ def decode_abi_strings(type_str: TypeStr, data: Any) -> Tuple[TypeStr, str]:
 
 
 def parse_basic_type_str(
-    old_normalizer: Callable[[BasicType, TypeStr, Any], Tuple[TypeStr, Any]],
-) -> Callable[[TypeStr, Any], Tuple[TypeStr, Any]]:
+    old_normalizer: Callable[[BasicType, TypeStr, Any], tuple[TypeStr, Any]],
+) -> Callable[[TypeStr, Any], tuple[TypeStr, Any]]:
     """
     Modifies a normalizer to automatically parse the incoming type string.  If
     that type string does not represent a basic type (i.e. non-tuple type) or is
@@ -121,7 +118,7 @@ def parse_basic_type_str(
     """
 
     @functools.wraps(old_normalizer)
-    def new_normalizer(type_str: TypeStr, data: Any) -> Tuple[TypeStr, Any]:
+    def new_normalizer(type_str: TypeStr, data: Any) -> tuple[TypeStr, Any]:
         try:
             abi_type = parse(type_str)
         except ParseError:
@@ -140,7 +137,7 @@ def parse_basic_type_str(
 @parse_basic_type_str
 def abi_bytes_to_hex(
     abi_type: BasicType, type_str: TypeStr, data: Any
-) -> Optional[Tuple[TypeStr, HexStr]]:
+) -> tuple[TypeStr, HexStr] | None:
     if abi_type.base != "bytes" or abi_type.is_array:
         return None
 
@@ -163,7 +160,7 @@ def abi_bytes_to_hex(
 @parse_basic_type_str
 def abi_int_to_hex(
     abi_type: BasicType, type_str: TypeStr, data: Any
-) -> Optional[Tuple[TypeStr, HexStr]]:
+) -> tuple[TypeStr, HexStr] | None:
     if abi_type.base == "uint" and not abi_type.is_array:
         # double check?
         return type_str, hexstr_if_str(to_hex, data)
@@ -171,14 +168,14 @@ def abi_int_to_hex(
 
 
 @implicitly_identity
-def abi_string_to_hex(type_str: TypeStr, data: Any) -> Optional[Tuple[TypeStr, str]]:
+def abi_string_to_hex(type_str: TypeStr, data: Any) -> tuple[TypeStr, str] | None:
     if type_str == "string":
         return type_str, text_if_str(to_hex, data)
     return None
 
 
 @implicitly_identity
-def abi_string_to_text(type_str: TypeStr, data: Any) -> Optional[Tuple[TypeStr, str]]:
+def abi_string_to_text(type_str: TypeStr, data: Any) -> tuple[TypeStr, str] | None:
     if type_str == "string":
         return type_str, text_if_str(to_text, data)
     return None
@@ -188,7 +185,7 @@ def abi_string_to_text(type_str: TypeStr, data: Any) -> Optional[Tuple[TypeStr,
 @parse_basic_type_str
 def abi_bytes_to_bytes(
     abi_type: BasicType, type_str: TypeStr, data: Any
-) -> Optional[Tuple[TypeStr, HexStr]]:
+) -> tuple[TypeStr, HexStr] | None:
     if abi_type.base == "bytes" and not abi_type.is_array:
         return type_str, hexstr_if_str(to_bytes, data)
     return None
@@ -197,7 +194,7 @@ def abi_bytes_to_bytes(
 @implicitly_identity
 def abi_address_to_hex(
     type_str: TypeStr, data: Any
-) -> Optional[Tuple[TypeStr, ChecksumAddress]]:
+) -> tuple[TypeStr, ChecksumAddress] | None:
     if type_str == "address":
         validate_address(data)
         if is_binary_address(data):
@@ -210,7 +207,7 @@ def abi_ens_resolver(
     w3: "Web3",
     type_str: TypeStr,
     val: Any,
-) -> Tuple[TypeStr, Any]:
+) -> tuple[TypeStr, Any]:
     if type_str == "address" and is_ens_name(val):
         if w3 is None:
             raise InvalidAddress(
@@ -247,7 +244,7 @@ BASE_RETURN_NORMALIZERS = [
 #
 
 
-def normalize_abi(abi: Union[ABI, str]) -> ABI:
+def normalize_abi(abi: ABI | str) -> ABI:
     if isinstance(abi, str):
         abi = json.loads(abi)
     validate_abi(cast(ABI, abi))
@@ -255,8 +252,8 @@ def normalize_abi(abi: Union[ABI, str]) -> ABI:
 
 
 def normalize_address(
-    ens: ENS, address: Optional[ChecksumAddress]
-) -> Union[ChecksumAddress, None]:
+    ens: ENS, address: ChecksumAddress | None
+) -> ChecksumAddress | None:
     if address:
         if is_ens_name(address):
             validate_name_has_address(ens, address)
@@ -266,14 +263,14 @@ def normalize_address(
 
 
 def normalize_address_no_ens(
-    address: Optional[ChecksumAddress],
-) -> Union[ChecksumAddress, None]:
+    address: ChecksumAddress | None,
+) -> ChecksumAddress | None:
     if address:
         validate_address(address)
     return address
 
 
-def normalize_bytecode(bytecode: Optional[bytes]) -> Union[HexBytes, None]:
+def normalize_bytecode(bytecode: bytes | None) -> HexBytes | None:
     if bytecode is not None:
         return HexBytes(bytecode)
     return bytecode
@@ -286,7 +283,7 @@ async def async_abi_ens_resolver(
     async_w3: "AsyncWeb3[Any]",
     type_str: TypeStr,
     val: Any,
-) -> Tuple[TypeStr, Any]:
+) -> tuple[TypeStr, Any]:
     if type_str == "address" and is_ens_name(val):
         if async_w3 is None:
             raise InvalidAddress(

web3/_utils/rpc_abi.py

@@ -1,11 +1,8 @@
 from typing import (
     Any,
     Callable,
-    Dict,
     Iterable,
     Sequence,
-    Tuple,
-    Union,
 )
 
 from eth_typing import (
@@ -174,7 +171,7 @@ TRACE_FILTER_PARAM_ABIS = {
     "count": "int",
 }
 
-RPC_ABIS: Dict[str, Union[Sequence[Any], Dict[str, str]]] = {
+RPC_ABIS: dict[str, Sequence[Any] | dict[str, str]] = {
     # eth
     "eth_call": TRANSACTION_PARAMS_ABIS,
     "eth_createAccessList": TRANSACTION_PARAMS_ABIS,
@@ -208,10 +205,10 @@ RPC_ABIS: Dict[str, Union[Sequence[Any], Dict[str, str]]] = {
 
 @curry
 def apply_abi_formatters_to_dict(
-    normalizers: Sequence[Callable[[TypeStr, Any], Tuple[TypeStr, Any]]],
-    abi_dict: Dict[str, Any],
-    data: Dict[Any, Any],
-) -> Dict[Any, Any]:
+    normalizers: Sequence[Callable[[TypeStr, Any], tuple[TypeStr, Any]]],
+    abi_dict: dict[str, Any],
+    data: dict[Any, Any],
+) -> dict[Any, Any]:
     fields = list(abi_dict.keys() & data.keys())
     formatted_values = map_abi_data(
         normalizers,
@@ -225,9 +222,9 @@ def apply_abi_formatters_to_dict(
 
 @to_dict
 def abi_request_formatters(
-    normalizers: Sequence[Callable[[TypeStr, Any], Tuple[TypeStr, Any]]],
-    abis: Dict[RPCEndpoint, Any],
-) -> Iterable[Tuple[RPCEndpoint, Callable[..., Any]]]:
+    normalizers: Sequence[Callable[[TypeStr, Any], tuple[TypeStr, Any]]],
+    abis: dict[RPCEndpoint, Any],
+) -> Iterable[tuple[RPCEndpoint, Callable[..., Any]]]:
     for method, abi_types in abis.items():
         if isinstance(abi_types, list):
             yield method, map_abi_data(normalizers, abi_types)

web3/_utils/threads.py

@@ -13,7 +13,6 @@ from typing import (
     Callable,
     Generic,
     Literal,
-    Type,
 )
 
 from web3.exceptions import (
@@ -37,7 +36,7 @@ class Timeout(Exception):
     def __init__(
         self,
         seconds: float = None,
-        exception: Type[BaseException] = None,
+        exception: type[BaseException] = None,
         *args: Any,
         **kwargs: Any,
     ) -> None:
@@ -50,7 +49,7 @@ class Timeout(Exception):
 
     def __exit__(
         self,
-        exc_type: Type[BaseException],
+        exc_type: type[BaseException],
         exc_val: BaseException,
         exc_tb: TracebackType,
     ) -> Literal[False]:
@@ -152,7 +151,7 @@ class TimerClass(threading.Thread):
 def spawn(
     target: Callable[..., TReturn],
     *args: Any,
-    thread_class: Type[ThreadWithReturn[TReturn]] = ThreadWithReturn,
+    thread_class: type[ThreadWithReturn[TReturn]] = ThreadWithReturn,
     **kwargs: Any,
 ) -> ThreadWithReturn[TReturn]:
     thread = thread_class(

web3/_utils/transactions.py

@@ -2,10 +2,7 @@ import math
 from typing import (
     TYPE_CHECKING,
     Any,
-    Dict,
-    List,
     Literal,
-    Optional,
     Union,
     cast,
 )
@@ -57,7 +54,7 @@ TX_PARAM_LITERALS = Literal[
     "blobVersionedHashes",
 ]
 
-VALID_TRANSACTION_PARAMS: List[TX_PARAM_LITERALS] = [
+VALID_TRANSACTION_PARAMS: list[TX_PARAM_LITERALS] = [
     "type",
     "from",
     "to",
@@ -121,7 +118,7 @@ def fill_transaction_defaults(w3: "Web3", transaction: TxParams) -> TxParams:
         or any_in_dict(DYNAMIC_FEE_TXN_PARAMS, transaction)
     )
 
-    defaults: Dict[str, Union[bytes, int]] = {}
+    defaults: dict[str, bytes | int] = {}
     for key, default_getter in TRANSACTION_DEFAULTS.items():
         if key not in transaction:
             if (
@@ -148,7 +145,7 @@ def fill_transaction_defaults(w3: "Web3", transaction: TxParams) -> TxParams:
 
 
 def get_block_gas_limit(
-    w3: "Web3", block_identifier: Optional[BlockIdentifier] = None
+    w3: "Web3", block_identifier: BlockIdentifier | None = None
 ) -> int:
     block = w3.eth.get_block(block_identifier or "latest")
     return block["gasLimit"]

web3/_utils/type_conversion.py

@@ -1,7 +1,3 @@
-from typing import (
-    Union,
-)
-
 from eth_typing import (
     HexStr,
 )
@@ -15,7 +11,7 @@ from web3.exceptions import (
 )
 
 
-def to_hex_if_bytes(val: Union[HexStr, str, bytes, bytearray]) -> HexStr:
+def to_hex_if_bytes(val: HexStr | str | bytes | bytearray) -> HexStr:
     """
     Note: This method does not validate against all cases and is only
     meant to work with bytes and hex strings.
@@ -26,7 +22,7 @@ def to_hex_if_bytes(val: Union[HexStr, str, bytes, bytearray]) -> HexStr:
     return to_hex(val) if isinstance(val, (bytes, bytearray)) else to_hex(hexstr=val)
 
 
-def to_bytes_if_hex(val: Union[HexStr, str, bytes, bytearray]) -> bytes:
+def to_bytes_if_hex(val: HexStr | str | bytes | bytearray) -> bytes:
     """
     Note: This method does not validate against all cases and is only
     meant to work with bytes and hex strings.

web3/_utils/utility_methods.py

@@ -2,8 +2,6 @@ from typing import (
     Any,
     Iterable,
     Mapping,
-    Set,
-    Union,
 )
 
 from web3.types import (
@@ -13,7 +11,7 @@ from web3.types import (
 
 
 def all_in_dict(
-    values: Iterable[Any], d: Union[Mapping[Any, Any], TxData, TxParams]
+    values: Iterable[Any], d: Mapping[Any, Any] | TxData | TxParams
 ) -> bool:
     """
     Returns a bool based on whether ALL of the provided values exist
@@ -29,7 +27,7 @@ def all_in_dict(
 
 
 def any_in_dict(
-    values: Iterable[Any], d: Union[Mapping[Any, Any], TxData, TxParams]
+    values: Iterable[Any], d: Mapping[Any, Any] | TxData | TxParams
 ) -> bool:
     """
     Returns a bool based on whether ANY of the provided values exist
@@ -45,7 +43,7 @@ def any_in_dict(
 
 
 def none_in_dict(
-    values: Iterable[Any], d: Union[Mapping[Any, Any], TxData, TxParams]
+    values: Iterable[Any], d: Mapping[Any, Any] | TxData | TxParams
 ) -> bool:
     """
     Returns a bool based on whether NONE of the provided values exist
@@ -60,8 +58,8 @@ def none_in_dict(
 
 
 def either_set_is_a_subset(
-    set1: Set[Any],
-    set2: Set[Any],
+    set1: set[Any],
+    set2: set[Any],
     percentage: int = 100,
 ) -> bool:
     """

web3/_utils/validation.py

@@ -3,9 +3,7 @@ import logging
 from typing import (
     Any,
     Callable,
-    Dict,
     NoReturn,
-    Optional,
 )
 
 from eth_typing import (
@@ -75,7 +73,7 @@ from web3.types import (
 )
 
 
-def _prepare_selector_collision_msg(duplicates: Dict[HexStr, ABIFunction]) -> str:
+def _prepare_selector_collision_msg(duplicates: dict[HexStr, ABIFunction]) -> str:
     dup_sel = valmap(apply_formatter_to_array(abi_to_signature), duplicates)
     joined_funcs = valmap(lambda funcs: ", ".join(funcs), dup_sel)
     func_sel_msg_list = [
@@ -264,7 +262,7 @@ def _raise_bad_response_format(response: RPCResponse, error: str = "") -> None:
 
 def raise_error_for_batch_response(
     response: RPCResponse,
-    logger: Optional[logging.Logger] = None,
+    logger: logging.Logger | None = None,
 ) -> NoReturn:
     error = response.get("error")
     if error is None:
@@ -288,10 +286,10 @@ def raise_error_for_batch_response(
 
 def validate_rpc_response_and_raise_if_error(
     response: RPCResponse,
-    error_formatters: Optional[Callable[..., Any]],
+    error_formatters: Callable[..., Any] | None,
     is_subscription_response: bool = False,
-    logger: Optional[logging.Logger] = None,
-    params: Optional[Any] = None,
+    logger: logging.Logger | None = None,
+    params: Any | None = None,
 ) -> None:
     if "jsonrpc" not in response or response["jsonrpc"] != "2.0":
         _raise_bad_response_format(
@@ -335,7 +333,7 @@ def validate_rpc_response_and_raise_if_error(
             response, 'Response must include either "error" or "result".'
         )
     elif "error" in response:
-        web3_rpc_error: Optional[Web3RPCError] = None
+        web3_rpc_error: Web3RPCError | None = None
         error = response["error"]
 
         # raise the error when the value is a string

web3/_utils/windows.py

@@ -1,7 +1,4 @@
 import sys
-from typing import (
-    Tuple,
-)
 
 import pywintypes  # noqa: E402
 import win32file  # noqa: E402
@@ -31,7 +28,7 @@ class NamedPipe:
             raise OSError(err)
         return data
 
-    def sendall(self, data: str) -> Tuple[int, int]:
+    def sendall(self, data: str) -> tuple[int, int]:
         return win32file.WriteFile(self.handle, data)
 
     def close(self) -> None: