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

web3/main.py

@@ -30,18 +30,17 @@ from functools import (
 from hexbytes import (
     HexBytes,
 )
+from collections.abc import (
+    AsyncIterator,
+)
 from typing import (
-    TYPE_CHECKING,
     Any,
-    AsyncIterator,
     Callable,
-    Dict,
     Generator,
     Generic,
-    List,
     Optional,
     Sequence,
-    Type,
+    TYPE_CHECKING,
     TypeVar,
     Union,
     cast,
@@ -135,7 +134,6 @@ from web3.providers.rpc import (
     HTTPProvider,
 )
 from web3.providers import (
-    LegacyWebSocketProvider,
     WebSocketProvider,
 )
 from web3.providers.persistent import (
@@ -160,7 +158,7 @@ if TYPE_CHECKING:
     from web3.providers.persistent import PersistentConnectionProvider  # noqa: F401
 
 
-def get_async_default_modules() -> Dict[str, Union[Type[Module], Sequence[Any]]]:
+def get_async_default_modules() -> dict[str, type[Module] | Sequence[Any]]:
     return {
         "eth": AsyncEth,
         "net": AsyncNet,
@@ -175,7 +173,7 @@ def get_async_default_modules() -> Dict[str, Union[Type[Module], Sequence[Any]]]
     }
 
 
-def get_default_modules() -> Dict[str, Union[Type[Module], Sequence[Any]]]:
+def get_default_modules() -> dict[str, type[Module] | Sequence[Any]]:
     return {
         "eth": Eth,
         "net": Net,
@@ -200,9 +198,9 @@ class BaseWeb3:
     manager: DefaultRequestManager
 
     # mypy types
-    eth: Union[Eth, AsyncEth]
-    net: Union[Net, AsyncNet]
-    geth: Union[Geth, AsyncGeth]
+    eth: Eth | AsyncEth
+    net: Net | AsyncNet
+    geth: Geth | AsyncGeth
 
     @property
     def middleware_onion(self) -> MiddlewareOnion:
@@ -212,53 +210,53 @@ class BaseWeb3:
     @staticmethod
     @wraps(to_bytes)
     def to_bytes(
-        primitive: Optional[Primitives] = None,
-        hexstr: Optional[HexStr] = None,
-        text: Optional[str] = None,
+        primitive: Primitives | None = None,
+        hexstr: HexStr | None = None,
+        text: str | None = None,
     ) -> bytes:
         return to_bytes(primitive, hexstr, text)
 
     @staticmethod
     @wraps(to_int)
     def to_int(
-        primitive: Optional[Primitives] = None,
-        hexstr: Optional[HexStr] = None,
-        text: Optional[str] = None,
+        primitive: Primitives | None = None,
+        hexstr: HexStr | None = None,
+        text: str | None = None,
     ) -> int:
         return to_int(primitive, hexstr, text)
 
     @staticmethod
     @wraps(to_hex)
     def to_hex(
-        primitive: Optional[Primitives] = None,
-        hexstr: Optional[HexStr] = None,
-        text: Optional[str] = None,
+        primitive: Primitives | None = None,
+        hexstr: HexStr | None = None,
+        text: str | None = None,
     ) -> HexStr:
         return to_hex(primitive, hexstr, text)
 
     @staticmethod
     @wraps(to_text)
     def to_text(
-        primitive: Optional[Primitives] = None,
-        hexstr: Optional[HexStr] = None,
-        text: Optional[str] = None,
+        primitive: Primitives | None = None,
+        hexstr: HexStr | None = None,
+        text: str | None = None,
     ) -> str:
         return to_text(primitive, hexstr, text)
 
     @staticmethod
     @wraps(to_json)
-    def to_json(obj: Dict[Any, Any]) -> str:
+    def to_json(obj: dict[Any, Any]) -> str:
         return to_json(obj)
 
     # Currency Utility
     @staticmethod
     @wraps(to_wei)
-    def to_wei(number: Union[int, float, str, decimal.Decimal], unit: str) -> Wei:
+    def to_wei(number: int | float | str | decimal.Decimal, unit: str) -> Wei:
         return cast(Wei, to_wei(number, unit))
 
     @staticmethod
     @wraps(from_wei)
-    def from_wei(number: int, unit: str) -> Union[int, decimal.Decimal]:
+    def from_wei(number: int, unit: str) -> int | decimal.Decimal:
         return from_wei(number, unit)
 
     # Address Utility
@@ -274,7 +272,7 @@ class BaseWeb3:
 
     @staticmethod
     @wraps(to_checksum_address)
-    def to_checksum_address(value: Union[AnyAddress, str, bytes]) -> ChecksumAddress:
+    def to_checksum_address(value: AnyAddress | str | bytes) -> ChecksumAddress:
         return to_checksum_address(value)
 
     @property
@@ -299,9 +297,9 @@ class BaseWeb3:
     @staticmethod
     @apply_to_return_value(HexBytes)
     def keccak(
-        primitive: Optional[Primitives] = None,
-        text: Optional[str] = None,
-        hexstr: Optional[HexStr] = None,
+        primitive: Primitives | None = None,
+        text: str | None = None,
+        hexstr: HexStr | None = None,
     ) -> bytes:
         if isinstance(primitive, (bytes, int, type(None))):
             input_bytes = to_bytes(primitive, hexstr=hexstr, text=text)
@@ -316,12 +314,12 @@ class BaseWeb3:
 
     @classmethod
     def normalize_values(
-        cls, w3: "BaseWeb3", abi_types: List[TypeStr], values: List[Any]
-    ) -> List[Any]:
+        cls, w3: "BaseWeb3", abi_types: list[TypeStr], values: list[Any]
+    ) -> list[Any]:
         return map_abi_data([abi_ens_resolver(w3)], abi_types, values)
 
     @combomethod
-    def solidity_keccak(cls, abi_types: List[TypeStr], values: List[Any]) -> bytes:
+    def solidity_keccak(cls, abi_types: list[TypeStr], values: list[Any]) -> bytes:
         """
         Executes keccak256 exactly as Solidity does.
         Takes list of abi_types as inputs -- `[uint24, int8[], bool]`
@@ -349,9 +347,7 @@ class BaseWeb3:
         )
         return cls.keccak(hexstr=hex_string)
 
-    def attach_modules(
-        self, modules: Dict[str, Union[Type[Module], Sequence[Any]]]
-    ) -> None:
+    def attach_modules(self, modules: dict[str, type[Module] | Sequence[Any]]) -> None:
         """
         Attach modules to the `Web3` instance.
         """
@@ -370,7 +366,7 @@ class BaseWeb3:
 
 def _validate_provider(
     w3: Union["Web3", "AsyncWeb3[Any]"],
-    provider: Optional[Union[BaseProvider, AsyncBaseProvider]],
+    provider: BaseProvider | AsyncBaseProvider | None,
 ) -> None:
     if provider is not None:
         if isinstance(w3, AsyncWeb3) and not isinstance(provider, AsyncBaseProvider):
@@ -396,16 +392,13 @@ class Web3(BaseWeb3):
     HTTPProvider = HTTPProvider
     IPCProvider = IPCProvider
     EthereumTesterProvider = EthereumTesterProvider
-    LegacyWebSocketProvider = LegacyWebSocketProvider
 
     def __init__(
         self,
-        provider: Optional[BaseProvider] = None,
-        middleware: Optional[Sequence[Any]] = None,
-        modules: Optional[Dict[str, Union[Type[Module], Sequence[Any]]]] = None,
-        external_modules: Optional[
-            Dict[str, Union[Type[Module], Sequence[Any]]]
-        ] = None,
+        provider: BaseProvider | None = None,
+        middleware: Sequence[Any] | None = None,
+        modules: dict[str, type[Module] | Sequence[Any]] | None = None,
+        external_modules: None | (dict[str, type[Module] | Sequence[Any]]) = None,
         ens: Union[ENS, "Empty"] = empty,
     ) -> None:
         _validate_provider(self, provider)
@@ -473,12 +466,10 @@ class AsyncWeb3(BaseWeb3, Generic[AsyncProviderT]):
 
     def __init__(
         self,
-        provider: Optional[AsyncProviderT] = None,
-        middleware: Optional[Sequence[Any]] = None,
-        modules: Optional[Dict[str, Union[Type[Module], Sequence[Any]]]] = None,
-        external_modules: Optional[
-            Dict[str, Union[Type[Module], Sequence[Any]]]
-        ] = None,
+        provider: AsyncProviderT | None = None,
+        middleware: Sequence[Any] | None = None,
+        modules: dict[str, type[Module] | Sequence[Any]] | None = None,
+        external_modules: None | (dict[str, type[Module] | Sequence[Any]]) = None,
         ens: Union[AsyncENS, "Empty"] = empty,
     ) -> None:
         _validate_provider(self, provider)
@@ -526,7 +517,7 @@ class AsyncWeb3(BaseWeb3, Generic[AsyncProviderT]):
 
     # -- persistent connection settings -- #
 
-    _subscription_manager: Optional[SubscriptionManager] = None
+    _subscription_manager: SubscriptionManager | None = None
     _persistent_connection: Optional["PersistentConnection"] = None
 
     @property
@@ -573,7 +564,7 @@ class AsyncWeb3(BaseWeb3, Generic[AsyncProviderT]):
     @persistent_connection_provider_method()
     async def __aexit__(
         self,
-        exc_type: Type[BaseException],
+        exc_type: type[BaseException],
         exc_val: BaseException,
         exc_tb: TracebackType,
     ) -> None:

web3/manager.py

@@ -6,11 +6,7 @@ from typing import (
     AsyncGenerator,
     Callable,
     Coroutine,
-    Dict,
-    List,
-    Optional,
     Sequence,
-    Tuple,
     Union,
     cast,
 )
@@ -106,8 +102,8 @@ class RequestManager:
     def __init__(
         self,
         w3: Union["AsyncWeb3[Any]", "Web3"],
-        provider: Optional[Union["BaseProvider", "AsyncBaseProvider"]] = None,
-        middleware: Optional[Sequence[Tuple[Middleware, str]]] = None,
+        provider: Union["BaseProvider", "AsyncBaseProvider"] | None = None,
+        middleware: Sequence[tuple[Middleware, str]] | None = None,
     ) -> None:
         self.w3 = w3
 
@@ -136,7 +132,7 @@ class RequestManager:
         self._provider = provider
 
     @staticmethod
-    def get_default_middleware() -> List[Tuple[Middleware, str]]:
+    def get_default_middleware() -> list[tuple[Middleware, str]]:
         """
         List the default middleware for the request manager.
         Documentation should remain in sync with these defaults.
@@ -153,7 +149,7 @@ class RequestManager:
     # Provider requests and response
     #
     def _make_request(
-        self, method: Union[RPCEndpoint, Callable[..., RPCEndpoint]], params: Any
+        self, method: RPCEndpoint | Callable[..., RPCEndpoint], params: Any
     ) -> RPCResponse:
         provider = cast("BaseProvider", self.provider)
         request_func = provider.request_func(
@@ -163,7 +159,7 @@ class RequestManager:
         return request_func(method, params)
 
     async def _coro_make_request(
-        self, method: Union[RPCEndpoint, Callable[..., RPCEndpoint]], params: Any
+        self, method: RPCEndpoint | Callable[..., RPCEndpoint], params: Any
     ) -> RPCResponse:
         provider = cast("AsyncBaseProvider", self.provider)
         request_func = await provider.request_func(
@@ -186,8 +182,8 @@ class RequestManager:
         self,
         response: RPCResponse,
         params: Any,
-        error_formatters: Optional[Callable[..., Any]] = None,
-        null_result_formatters: Optional[Callable[..., Any]] = None,
+        error_formatters: Callable[..., Any] | None = None,
+        null_result_formatters: Callable[..., Any] | None = None,
     ) -> Any:
         is_subscription_response = (
             response.get("method") == "eth_subscription"
@@ -221,10 +217,10 @@ class RequestManager:
 
     def request_blocking(
         self,
-        method: Union[RPCEndpoint, Callable[..., RPCEndpoint]],
+        method: RPCEndpoint | Callable[..., RPCEndpoint],
         params: Any,
-        error_formatters: Optional[Callable[..., Any]] = None,
-        null_result_formatters: Optional[Callable[..., Any]] = None,
+        error_formatters: Callable[..., Any] | None = None,
+        null_result_formatters: Callable[..., Any] | None = None,
     ) -> Any:
         """
         Make a synchronous request using the provider
@@ -236,10 +232,10 @@ class RequestManager:
 
     async def coro_request(
         self,
-        method: Union[RPCEndpoint, Callable[..., RPCEndpoint]],
+        method: RPCEndpoint | Callable[..., RPCEndpoint],
         params: Any,
-        error_formatters: Optional[Callable[..., Any]] = None,
-        null_result_formatters: Optional[Callable[..., Any]] = None,
+        error_formatters: Callable[..., Any] | None = None,
+        null_result_formatters: Callable[..., Any] | None = None,
     ) -> Any:
         """
         Coroutine for making a request using the provider
@@ -262,8 +258,8 @@ class RequestManager:
         return RequestBatcher(self.w3)
 
     def _make_batch_request(
-        self, requests_info: List[Tuple[Tuple["RPCEndpoint", Any], Tuple[Any, ...]]]
-    ) -> List[RPCResponse]:
+        self, requests_info: list[tuple[tuple["RPCEndpoint", Any], tuple[Any, ...]]]
+    ) -> list[RPCResponse]:
         """
         Make a batch request using the provider
         """
@@ -291,10 +287,10 @@ class RequestManager:
 
     async def _async_make_batch_request(
         self,
-        requests_info: List[
-            Coroutine[Any, Any, Tuple[Tuple["RPCEndpoint", Any], Tuple[Any]]]
+        requests_info: list[
+            Coroutine[Any, Any, tuple[tuple["RPCEndpoint", Any], tuple[Any]]]
         ],
-    ) -> List[RPCResponse]:
+    ) -> list[RPCResponse]:
         """
         Make an asynchronous batch request using the provider
         """
@@ -315,7 +311,7 @@ class RequestManager:
 
         if isinstance(response, list):
             # expected format
-            response = cast(List[RPCResponse], response)
+            response = cast(list[RPCResponse], response)
             formatted_responses = [
                 self._format_batched_response(info, resp)
                 for info, resp in zip(unpacked_requests_info, response)
@@ -326,8 +322,8 @@ class RequestManager:
             raise_error_for_batch_response(response, self.logger)
 
     async def _async_send_batch(
-        self, requests: List[Tuple["RPCEndpoint", Any]]
-    ) -> List[RPCRequest]:
+        self, requests: list[tuple["RPCEndpoint", Any]]
+    ) -> list[RPCRequest]:
         """
         Send a batch request via socket.
         """
@@ -346,7 +342,7 @@ class RequestManager:
         )
         return await send_func(requests)
 
-    async def _async_recv_batch(self, requests: List[RPCRequest]) -> List[RPCResponse]:
+    async def _async_recv_batch(self, requests: list[RPCRequest]) -> list[RPCResponse]:
         """
         Receive a batch request via socket.
         """
@@ -367,10 +363,10 @@ class RequestManager:
 
     async def _async_make_socket_batch_request(
         self,
-        requests_info: List[
-            Coroutine[Any, Any, Tuple[Tuple["RPCEndpoint", Any], Tuple[Any, ...]]]
+        requests_info: list[
+            Coroutine[Any, Any, tuple[tuple["RPCEndpoint", Any], tuple[Any, ...]]]
         ],
-    ) -> List[RPCResponse]:
+    ) -> list[RPCResponse]:
         """
         Send and receive a batch request via a socket.
         """
@@ -407,7 +403,7 @@ class RequestManager:
 
     def _format_batched_response(
         self,
-        requests_info: Tuple[Tuple[RPCEndpoint, Any], Sequence[Any]],
+        requests_info: tuple[tuple[RPCEndpoint, Any], Sequence[Any]],
         response: RPCResponse,
     ) -> RPCResponse:
         result_formatters, error_formatters, null_result_formatters = requests_info[1]
@@ -434,9 +430,10 @@ class RequestManager:
         self,
         method: RPCEndpoint,
         params: Any,
-        response_formatters: Optional[
-            Tuple[Dict[str, Callable[..., Any]], Callable[..., Any], Callable[..., Any]]
-        ] = None,
+        response_formatters: None
+        | (
+            tuple[dict[str, Callable[..., Any]], Callable[..., Any], Callable[..., Any]]
+        ) = None,
     ) -> RPCResponse:
         provider = cast(PersistentConnectionProvider, self._provider)
         self.logger.debug(
@@ -495,7 +492,7 @@ class RequestManager:
             provider._request_processor._request_information_cache.pop(response_id_key)
             raise
 
-    async def recv(self) -> Union[RPCResponse, FormattedEthSubscriptionResponse]:
+    async def recv(self) -> RPCResponse | FormattedEthSubscriptionResponse:
         provider = cast(PersistentConnectionProvider, self._provider)
         self.logger.debug(
             "Getting next response from open socket connection: %s",
@@ -559,7 +556,7 @@ class RequestManager:
 
     async def _process_response(
         self, response: RPCResponse
-    ) -> Union[RPCResponse, FormattedEthSubscriptionResponse]:
+    ) -> RPCResponse | FormattedEthSubscriptionResponse:
         provider = cast(PersistentConnectionProvider, self._provider)
         request_info = self._request_processor.get_request_information_for_response(
             response

web3/method.py

@@ -3,14 +3,9 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
-    Dict,
     Generic,
-    List,
     Optional,
     Sequence,
-    Tuple,
-    Type,
-    Union,
 )
 import warnings
 
@@ -58,17 +53,15 @@ Munger = Callable[..., Any]
 
 @to_tuple
 def _apply_request_formatters(
-    params: Any, request_formatters: Dict[RPCEndpoint, Callable[..., TReturn]]
-) -> Tuple[Any, ...]:
+    params: Any, request_formatters: dict[RPCEndpoint, Callable[..., TReturn]]
+) -> tuple[Any, ...]:
     if request_formatters:
         formatted_params = pipe(params, request_formatters)
         return formatted_params
     return params
 
 
-def _set_mungers(
-    mungers: Optional[Sequence[Munger]], is_property: bool
-) -> Sequence[Any]:
+def _set_mungers(mungers: Sequence[Munger] | None, is_property: bool) -> Sequence[Any]:
     if is_property and mungers:
         raise Web3ValidationError("Mungers cannot be used with a property.")
 
@@ -81,13 +74,13 @@ def _set_mungers(
     )
 
 
-def default_munger(_module: "Module", *args: Any, **kwargs: Any) -> Tuple[()]:
+def default_munger(_module: "Module", *args: Any, **kwargs: Any) -> tuple[()]:
     if args or kwargs:
         raise Web3ValidationError("Parameters cannot be passed to a property.")
     return ()
 
 
-def default_root_munger(_module: "Module", *args: Any) -> List[Any]:
+def default_root_munger(_module: "Module", *args: Any) -> list[Any]:
     return [*args]
 
 
@@ -134,12 +127,12 @@ class Method(Generic[TFunc]):
 
     def __init__(
         self,
-        json_rpc_method: Optional[RPCEndpoint] = None,
-        mungers: Optional[Sequence[Munger]] = None,
-        request_formatters: Optional[Callable[..., TReturn]] = None,
-        result_formatters: Optional[Callable[..., TReturn]] = None,
-        null_result_formatters: Optional[Callable[..., TReturn]] = None,
-        method_choice_depends_on_args: Optional[Callable[..., RPCEndpoint]] = None,
+        json_rpc_method: RPCEndpoint | None = None,
+        mungers: Sequence[Munger] | None = None,
+        request_formatters: Callable[..., TReturn] | None = None,
+        result_formatters: Callable[..., TReturn] | None = None,
+        null_result_formatters: Callable[..., TReturn] | None = None,
+        method_choice_depends_on_args: Callable[..., RPCEndpoint] | None = None,
         is_property: bool = False,
     ):
         self.json_rpc_method = json_rpc_method
@@ -155,7 +148,7 @@ class Method(Generic[TFunc]):
     def __get__(
         self,
         module: Optional["Module"] = None,
-        _type: Optional[Type["Module"]] = None,
+        _type: type["Module"] | None = None,
     ) -> TFunc:
         self._module = module
         if module is None:
@@ -192,7 +185,7 @@ class Method(Generic[TFunc]):
             "``json_rpc_method`` config invalid.  May be a string or function"
         )
 
-    def input_munger(self, module: "Module", args: Any, kwargs: Any) -> List[Any]:
+    def input_munger(self, module: "Module", args: Any, kwargs: Any) -> list[Any]:
         # This function takes the input parameters and munges them.
         # See the test_process_params test in ``tests/core/method-class/test_method.py``
         # for an example with multiple mungers.
@@ -202,12 +195,12 @@ class Method(Generic[TFunc]):
 
     def process_params(
         self, module: "Module", *args: Any, **kwargs: Any
-    ) -> Tuple[
-        Tuple[Union[RPCEndpoint, Callable[..., RPCEndpoint]], Tuple[RPCEndpoint, ...]],
-        Tuple[
-            Union[TReturn, Dict[str, Callable[..., Any]]],
+    ) -> tuple[
+        tuple[RPCEndpoint | Callable[..., RPCEndpoint], tuple[RPCEndpoint, ...]],
+        tuple[
+            TReturn | dict[str, Callable[..., Any]],
             Callable[..., Any],
-            Union[TReturn, Callable[..., Any]],
+            TReturn | Callable[..., Any],
         ],
     ]:
         params = self.input_munger(module, args, kwargs)
@@ -243,9 +236,9 @@ class DeprecatedMethod:
     def __init__(
         self,
         method: Method[Callable[..., Any]],
-        old_name: Optional[str] = None,
-        new_name: Optional[str] = None,
-        msg: Optional[str] = None,
+        old_name: str | None = None,
+        new_name: str | None = None,
+        msg: str | None = None,
     ) -> None:
         self.method = method
         self.old_name = old_name
@@ -253,7 +246,7 @@ class DeprecatedMethod:
         self.msg = msg
 
     def __get__(
-        self, obj: Optional["Module"] = None, obj_type: Optional[Type["Module"]] = None
+        self, obj: Optional["Module"] = None, obj_type: type["Module"] | None = None
     ) -> Any:
         message = f"{self.old_name} is deprecated in favor of {self.new_name}"
         if self.msg is not None:

web3/middleware/base.py

@@ -4,9 +4,6 @@ from abc import (
 from typing import (
     TYPE_CHECKING,
     Any,
-    List,
-    Tuple,
-    Type,
     Union,
 )
 
@@ -61,8 +58,8 @@ class Web3Middleware:
         self, make_batch_request: "MakeBatchRequestFn"
     ) -> "MakeBatchRequestFn":
         def middleware(
-            requests_info: List[Tuple["RPCEndpoint", Any]],
-        ) -> Union[List["RPCResponse"], "RPCResponse"]:
+            requests_info: list[tuple["RPCEndpoint", Any]],
+        ) -> Union[list["RPCResponse"], "RPCResponse"]:
             req_processed = [
                 self.request_processor(method, params)
                 for (method, params) in requests_info
@@ -106,8 +103,8 @@ class Web3Middleware:
         self, make_batch_request: "AsyncMakeBatchRequestFn"
     ) -> "AsyncMakeBatchRequestFn":
         async def middleware(
-            requests_info: List[Tuple["RPCEndpoint", Any]],
-        ) -> Union[List["RPCResponse"], "RPCResponse"]:
+            requests_info: list[tuple["RPCEndpoint", Any]],
+        ) -> Union[list["RPCResponse"], "RPCResponse"]:
             req_processed = [
                 await self.async_request_processor(method, params)
                 for (method, params) in requests_info
@@ -186,5 +183,5 @@ class Web3MiddlewareBuilder(Web3Middleware):
 
 # --- type definitions --- #
 
-Middleware = Type[Web3Middleware]
+Middleware = type[Web3Middleware]
 MiddlewareOnion = NamedElementOnion[str, Middleware]