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

web3/providers/base.py

@@ -6,11 +6,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
-    List,
     Optional,
-    Set,
-    Tuple,
-    Union,
     cast,
 )
 
@@ -60,7 +56,7 @@ class BaseProvider:
     # Set generic logger for the provider. Override in subclasses for more specificity.
     logger: logging.Logger = logging.getLogger("web3.providers.base.BaseProvider")
     # a tuple of (middleware, request_func)
-    _request_func_cache: Tuple[Tuple[Middleware, ...], Callable[..., RPCResponse]] = (
+    _request_func_cache: tuple[tuple[Middleware, ...], Callable[..., RPCResponse]] = (
         None,
         None,
     )
@@ -73,10 +69,9 @@ class BaseProvider:
     def __init__(
         self,
         cache_allowed_requests: bool = False,
-        cacheable_requests: Set[RPCEndpoint] = None,
-        request_cache_validation_threshold: Optional[
-            Union[RequestCacheValidationThreshold, int, Empty]
-        ] = empty,
+        cacheable_requests: set[RPCEndpoint] = None,
+        request_cache_validation_threshold: None
+        | (RequestCacheValidationThreshold | int | Empty) = empty,
     ) -> None:
         self._request_cache = SimpleCache(1000)
         self._request_cache_lock: threading.Lock = threading.Lock()
@@ -88,8 +83,8 @@ class BaseProvider:
         self._batching_context: contextvars.ContextVar[
             Optional["RequestBatcher[Any]"]
         ] = contextvars.ContextVar("batching_context", default=None)
-        self._batch_request_func_cache: Tuple[
-            Tuple[Middleware, ...], Callable[..., Union[List[RPCResponse], RPCResponse]]
+        self._batch_request_func_cache: tuple[
+            tuple[Middleware, ...], Callable[..., list[RPCResponse] | RPCResponse]
         ] = (None, None)
 
     @property
@@ -109,7 +104,7 @@ class BaseProvider:
         @returns a function that calls all the middleware and
             eventually self.make_request()
         """
-        middleware: Tuple[Middleware, ...] = middleware_onion.as_tuple_of_middleware()
+        middleware: tuple[Middleware, ...] = middleware_onion.as_tuple_of_middleware()
 
         cache_key = self._request_func_cache[0]
         if cache_key != middleware:
@@ -181,8 +176,8 @@ class JSONBaseProvider(BaseProvider):
 
     def batch_request_func(
         self, w3: "Web3", middleware_onion: MiddlewareOnion
-    ) -> Callable[..., Union[List[RPCResponse], RPCResponse]]:
-        middleware: Tuple[Middleware, ...] = middleware_onion.as_tuple_of_middleware()
+    ) -> Callable[..., list[RPCResponse] | RPCResponse]:
+        middleware: tuple[Middleware, ...] = middleware_onion.as_tuple_of_middleware()
 
         cache_key = self._batch_request_func_cache[0]
         if cache_key != middleware:
@@ -200,7 +195,7 @@ class JSONBaseProvider(BaseProvider):
         return self._batch_request_func_cache[-1]
 
     def encode_batch_rpc_request(
-        self, requests: List[Tuple[RPCEndpoint, Any]]
+        self, requests: list[tuple[RPCEndpoint, Any]]
     ) -> bytes:
         return (
             b"["
@@ -211,6 +206,6 @@ class JSONBaseProvider(BaseProvider):
         )
 
     def make_batch_request(
-        self, requests: List[Tuple[RPCEndpoint, Any]]
-    ) -> Union[List[RPCResponse], RPCResponse]:
+        self, requests: list[tuple[RPCEndpoint, Any]]
+    ) -> list[RPCResponse] | RPCResponse:
         raise NotImplementedError("Providers must implement this method")

web3/providers/eth_tester/defaults.py

@@ -6,11 +6,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
-    List,
     NoReturn,
-    Optional,
-    Tuple,
-    Type,
 )
 
 from eth_abi import (
@@ -76,7 +72,7 @@ def call_eth_tester(
     fn_name: str,
     eth_tester: "EthereumTester",
     fn_args: Any,
-    fn_kwargs: Optional[Any] = None,
+    fn_kwargs: Any | None = None,
 ) -> RPCResponse:
     if fn_kwargs is None:
         fn_kwargs = {}
@@ -140,7 +136,7 @@ def without_params(
 @curry
 def preprocess_params(
     eth_tester: "EthereumTester", params: Any, preprocessor_fn: Callable[..., Any]
-) -> Tuple["EthereumTester", Callable[..., Any]]:
+) -> tuple["EthereumTester", Callable[..., Any]]:
     return eth_tester, preprocessor_fn(params)
 
 
@@ -163,7 +159,7 @@ def client_version(eth_tester: "EthereumTester", params: Any) -> str:
 
 @curry
 def null_if_excepts(
-    exc_type: Type[BaseException], fn: Callable[..., TReturn]
+    exc_type: type[BaseException], fn: Callable[..., TReturn]
 ) -> Callable[..., TReturn]:
     return excepts(
         exc_type,
@@ -206,7 +202,7 @@ def create_log_filter(eth_tester: "EthereumTester", params: Any) -> int:
     return filter_id
 
 
-def get_logs(eth_tester: "EthereumTester", params: Any) -> List[LogReceipt]:
+def get_logs(eth_tester: "EthereumTester", params: Any) -> list[LogReceipt]:
     filter_params = params[0]
     logs = eth_tester.get_logs(**filter_params)
     return logs

web3/providers/eth_tester/main.py

@@ -3,9 +3,7 @@ from typing import (
     Any,
     Callable,
     Coroutine,
-    Dict,
     Literal,
-    Optional,
     Union,
     cast,
 )
@@ -122,14 +120,12 @@ class EthereumTesterProvider(BaseProvider):
         ethereum_tester_middleware,
     )
     ethereum_tester = None
-    api_endpoints: Optional[Dict[str, Dict[str, Callable[..., RPCResponse]]]] = None
+    api_endpoints: dict[str, dict[str, Callable[..., RPCResponse]]] | None = None
 
     def __init__(
         self,
-        ethereum_tester: Optional[Union["EthereumTester", "BaseChainBackend"]] = None,
-        api_endpoints: Optional[
-            Dict[str, Dict[str, Callable[..., RPCResponse]]]
-        ] = None,
+        ethereum_tester: Union["EthereumTester", "BaseChainBackend"] | None = None,
+        api_endpoints: None | (dict[str, dict[str, Callable[..., RPCResponse]]]) = None,
     ) -> None:
         # do not import eth_tester until runtime, it is not a default dependency
         super().__init__()
@@ -215,7 +211,7 @@ def _make_response(result: Any, response_id: str, message: str = "") -> RPCRespo
 def _make_request(
     method: RPCEndpoint,
     params: Any,
-    api_endpoints: Dict[str, Dict[str, Any]],
+    api_endpoints: dict[str, dict[str, Any]],
     ethereum_tester_instance: "EthereumTester",
     request_id: str,
 ) -> RPCResponse:

web3/providers/eth_tester/middleware.py

@@ -3,8 +3,6 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
-    Dict,
-    Optional,
 )
 
 from eth_typing import (
@@ -307,7 +305,7 @@ request_formatters = {
     RPCEndpoint("evm_revert"): apply_formatters_to_args(hex_to_integer),
 }
 
-result_formatters: Optional[Dict[RPCEndpoint, Callable[..., Any]]] = {
+result_formatters: dict[RPCEndpoint, Callable[..., Any]] | None = {
     RPCEndpoint("eth_getBlockByHash"): apply_formatter_if(
         is_dict, compose(block_result_remapper, block_result_formatter)
     ),
@@ -377,7 +375,7 @@ def fill_default(
 
 async def async_guess_from(
     async_w3: "AsyncWeb3[Any]", _: TxParams
-) -> Optional[ChecksumAddress]:
+) -> ChecksumAddress | None:
     accounts = await async_w3.eth.accounts
     if accounts is not None and len(accounts) > 0:
         return accounts[0]

web3/providers/ipc.py

@@ -14,10 +14,6 @@ from types import (
 )
 from typing import (
     Any,
-    List,
-    Tuple,
-    Type,
-    Union,
     cast,
 )
 
@@ -77,7 +73,7 @@ class PersistentSocket:
 
     def __exit__(
         self,
-        exc_type: Type[BaseException],
+        exc_type: type[BaseException],
         exc_value: BaseException,
         traceback: TracebackType,
     ) -> None:
@@ -143,7 +139,7 @@ class IPCProvider(JSONBaseProvider):
 
     def __init__(
         self,
-        ipc_path: Union[str, Path] = None,
+        ipc_path: str | Path = None,
         timeout: int = 30,
         **kwargs: Any,
     ) -> None:
@@ -176,7 +172,7 @@ class IPCProvider(JSONBaseProvider):
                 while True:
                     try:
                         raw_response += sock.recv(4096)
-                    except socket.timeout:
+                    except TimeoutError:
                         timeout.sleep(0)
                         continue
                     if raw_response == b"":
@@ -202,11 +198,11 @@ class IPCProvider(JSONBaseProvider):
         return self._make_request(request)
 
     def make_batch_request(
-        self, requests: List[Tuple[RPCEndpoint, Any]]
-    ) -> List[RPCResponse]:
+        self, requests: list[tuple[RPCEndpoint, Any]]
+    ) -> list[RPCResponse]:
         self.logger.debug("Making batch request IPC. Path: %s", self.ipc_path)
         request_data = self.encode_batch_rpc_request(requests)
-        response = cast(List[RPCResponse], self._make_request(request_data))
+        response = cast(list[RPCResponse], self._make_request(request_data))
         return sort_batch_response_by_response_ids(response)
 
 

web3/providers/persistent/async_ipc.py

@@ -8,9 +8,6 @@ from pathlib import (
 import sys
 from typing import (
     Any,
-    Optional,
-    Tuple,
-    Union,
 )
 
 from web3.types import (
@@ -34,7 +31,7 @@ from ..ipc import (
 
 async def async_get_ipc_socket(
     ipc_path: str, read_buffer_limit: int
-) -> Tuple[asyncio.StreamReader, asyncio.StreamWriter]:
+) -> tuple[asyncio.StreamReader, asyncio.StreamWriter]:
     if sys.platform == "win32":
         # On Windows named pipe is used. Simulate socket with it.
         from web3._utils.windows import (
@@ -49,13 +46,13 @@ async def async_get_ipc_socket(
 class AsyncIPCProvider(PersistentConnectionProvider):
     logger = logging.getLogger("web3.providers.AsyncIPCProvider")
 
-    _reader: Optional[asyncio.StreamReader] = None
-    _writer: Optional[asyncio.StreamWriter] = None
+    _reader: asyncio.StreamReader | None = None
+    _writer: asyncio.StreamWriter | None = None
     _decoder: json.JSONDecoder = json.JSONDecoder()
 
     def __init__(
         self,
-        ipc_path: Optional[Union[str, Path]] = None,
+        ipc_path: str | Path | None = None,
         read_buffer_limit: int = 20 * 1024 * 1024,  # 20 MB
         # `PersistentConnectionProvider` kwargs can be passed through
         **kwargs: Any,

web3/providers/persistent/persistent.py

@@ -10,10 +10,7 @@ from typing import (
     Any,
     Callable,
     Coroutine,
-    List,
     Optional,
-    Tuple,
-    Union,
     cast,
 )
 
@@ -68,17 +65,17 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
     logger = logging.getLogger("web3.providers.PersistentConnectionProvider")
     has_persistent_connection = True
 
-    _send_func_cache: Tuple[
-        Optional[int], Optional[Callable[..., Coroutine[Any, Any, RPCRequest]]]
+    _send_func_cache: tuple[
+        int | None, Callable[..., Coroutine[Any, Any, RPCRequest]] | None
     ] = (None, None)
-    _recv_func_cache: Tuple[
-        Optional[int], Optional[Callable[..., Coroutine[Any, Any, RPCResponse]]]
+    _recv_func_cache: tuple[
+        int | None, Callable[..., Coroutine[Any, Any, RPCResponse]] | None
     ] = (None, None)
-    _send_batch_func_cache: Tuple[
-        Optional[int], Optional[Callable[..., Coroutine[Any, Any, List[RPCRequest]]]]
+    _send_batch_func_cache: tuple[
+        int | None, Callable[..., Coroutine[Any, Any, list[RPCRequest]]] | None
     ] = (None, None)
-    _recv_batch_func_cache: Tuple[
-        Optional[int], Optional[Callable[..., Coroutine[Any, Any, List[RPCResponse]]]]
+    _recv_batch_func_cache: tuple[
+        int | None, Callable[..., Coroutine[Any, Any, list[RPCResponse]]] | None
     ] = (None, None)
 
     def __init__(
@@ -157,15 +154,15 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
 
     async def send_batch_func(
         self, async_w3: "AsyncWeb3[Any]", middleware_onion: "MiddlewareOnion"
-    ) -> Callable[..., Coroutine[Any, Any, List[RPCRequest]]]:
+    ) -> Callable[..., Coroutine[Any, Any, list[RPCRequest]]]:
         middleware = middleware_onion.as_tuple_of_middleware()
         cache_key = hash(tuple(id(mw) for mw in middleware))
 
         if cache_key != self._send_batch_func_cache[0]:
 
             async def send_func(
-                requests: List[Tuple[RPCEndpoint, Any]],
-            ) -> List[RPCRequest]:
+                requests: list[tuple[RPCEndpoint, Any]],
+            ) -> list[RPCRequest]:
                 for mw in middleware:
                     initialized = mw(async_w3)
                     requests = [
@@ -180,15 +177,15 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
 
     async def recv_batch_func(
         self, async_w3: "AsyncWeb3[Any]", middleware_onion: "MiddlewareOnion"
-    ) -> Callable[..., Coroutine[Any, Any, List[RPCResponse]]]:
+    ) -> Callable[..., Coroutine[Any, Any, list[RPCResponse]]]:
         middleware = middleware_onion.as_tuple_of_middleware()
         cache_key = hash(tuple(id(mw) for mw in middleware))
 
         if cache_key != self._recv_batch_func_cache[0]:
 
             async def recv_function(
-                rpc_requests: List[RPCRequest],
-            ) -> List[RPCResponse]:
+                rpc_requests: list[RPCRequest],
+            ) -> list[RPCResponse]:
                 methods = [rpc_request["method"] for rpc_request in rpc_requests]
                 responses = await self.recv_for_batch_request(rpc_requests)
                 for mw in reversed(middleware):
@@ -296,8 +293,8 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
     # -- batch requests -- #
 
     async def send_batch_request(
-        self, requests: List[Tuple[RPCEndpoint, Any]]
-    ) -> List[RPCRequest]:
+        self, requests: list[tuple[RPCEndpoint, Any]]
+    ) -> list[RPCRequest]:
         request_dicts = [
             self.form_request(method, params) for (method, params) in requests
         ]
@@ -306,17 +303,17 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
         return request_dicts
 
     async def recv_for_batch_request(
-        self, _request_dicts: List[RPCRequest]
-    ) -> List[RPCResponse]:
+        self, _request_dicts: list[RPCRequest]
+    ) -> list[RPCResponse]:
         response = cast(
-            List[RPCResponse],
+            list[RPCResponse],
             await self._get_response_for_request_id(BATCH_REQUEST_ID),
         )
         return response
 
     async def make_batch_request(
-        self, requests: List[Tuple[RPCEndpoint, Any]]
-    ) -> List[RPCResponse]:
+        self, requests: list[tuple[RPCEndpoint, Any]]
+    ) -> list[RPCResponse]:
         request_dicts = await self.send_batch_request(requests)
         return await self.recv_for_batch_request(request_dicts)
 
@@ -471,7 +468,7 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
             raise msg_listener_task.exception()
 
     async def _get_response_for_request_id(
-        self, request_id: Union[RPCId, List[RPCId]], timeout: Optional[float] = None
+        self, request_id: RPCId | list[RPCId], timeout: float | None = None
     ) -> RPCResponse:
         if timeout is None:
             timeout = self.request_timeout

web3/providers/persistent/persistent_connection.py

@@ -1,8 +1,6 @@
 from typing import (
     TYPE_CHECKING,
     Any,
-    Dict,
-    Union,
     cast,
 )
 
@@ -35,7 +33,7 @@ class PersistentConnection:
         self.provider = cast("PersistentConnectionProvider", self._manager.provider)
 
     @property
-    def subscriptions(self) -> Dict[str, Any]:
+    def subscriptions(self) -> dict[str, Any]:
         """
         Return the active subscriptions on the persistent connection.
 
@@ -70,7 +68,7 @@ class PersistentConnection:
         """
         await self._manager.send(method, params)
 
-    async def recv(self) -> Union[RPCResponse, FormattedEthSubscriptionResponse]:
+    async def recv(self) -> RPCResponse | FormattedEthSubscriptionResponse:
         """
         Receive the next unprocessed response for a request from the persistent
         connection.

web3/providers/persistent/request_processor.py

@@ -1,16 +1,9 @@
 import asyncio
-import sys
 from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
-    Dict,
-    Generic,
-    List,
-    Optional,
-    Tuple,
     TypeVar,
-    Union,
 )
 
 from web3._utils.batching import (
@@ -44,20 +37,8 @@ if TYPE_CHECKING:
 
 T = TypeVar("T")
 
-# TODO: This is an ugly hack for python 3.8. Remove this after we drop support for it
-#  and use `asyncio.Queue[T]` type directly in the `TaskReliantQueue` class.
-if sys.version_info >= (3, 9):
 
-    class _TaskReliantQueue(asyncio.Queue[T], Generic[T]):
-        pass
-
-else:
-
-    class _TaskReliantQueue(asyncio.Queue, Generic[T]):  # type: ignore
-        pass
-
-
-class TaskReliantQueue(_TaskReliantQueue[T]):
+class TaskReliantQueue(asyncio.Queue[T]):
     """
     A queue that relies on a task to be running to process items in the queue.
     """
@@ -75,7 +56,7 @@ class RequestProcessor:
     _subscription_queue_synced_with_ws_stream: bool = False
 
     # set by the subscription manager when it is initialized
-    _subscription_container: Optional[SubscriptionContainer] = None
+    _subscription_container: SubscriptionContainer | None = None
 
     def __init__(
         self,
@@ -89,14 +70,14 @@ class RequestProcessor:
         )
         self._request_response_cache: SimpleCache = SimpleCache(500)
         self._subscription_response_queue: TaskReliantQueue[
-            Union[RPCResponse, TaskNotRunning]
+            RPCResponse | TaskNotRunning
         ] = TaskReliantQueue(maxsize=subscription_response_queue_size)
         self._handler_subscription_queue: TaskReliantQueue[
-            Union[RPCResponse, TaskNotRunning, SubscriptionProcessingFinished]
+            RPCResponse | TaskNotRunning | SubscriptionProcessingFinished
         ] = TaskReliantQueue(maxsize=subscription_response_queue_size)
 
     @property
-    def active_subscriptions(self) -> Dict[str, Any]:
+    def active_subscriptions(self) -> dict[str, Any]:
         return {
             value.subscription_id: {"params": value.params}
             for key, value in self._request_information_cache.items()
@@ -107,15 +88,15 @@ class RequestProcessor:
 
     def cache_request_information(
         self,
-        request_id: Optional[RPCId],
+        request_id: RPCId | None,
         method: RPCEndpoint,
         params: Any,
-        response_formatters: Tuple[
-            Union[Dict[str, Callable[..., Any]], Callable[..., Any]],
+        response_formatters: tuple[
+            dict[str, Callable[..., Any]] | Callable[..., Any],
             Callable[..., Any],
             Callable[..., Any],
         ],
-    ) -> Optional[str]:
+    ) -> str | None:
         cached_requests_key = generate_cache_key((method, params))
         if cached_requests_key in self._provider._request_cache._data:
             cached_response = self._provider._request_cache._data[cached_requests_key]
@@ -163,7 +144,7 @@ class RequestProcessor:
 
     def pop_cached_request_information(
         self, cache_key: str
-    ) -> Optional[RequestInformation]:
+    ) -> RequestInformation | None:
         request_info = self._request_information_cache.pop(cache_key)
         if request_info is not None:
             self._provider.logger.debug(
@@ -256,9 +237,7 @@ class RequestProcessor:
 
     # raw response cache
 
-    def _is_batch_response(
-        self, raw_response: Union[List[RPCResponse], RPCResponse]
-    ) -> bool:
+    def _is_batch_response(self, raw_response: list[RPCResponse] | RPCResponse) -> bool:
         return isinstance(raw_response, list) or (
             isinstance(raw_response, dict)
             and raw_response.get("id") is None

web3/providers/persistent/subscription_container.py

@@ -1,9 +1,6 @@
 from typing import (
     Any,
-    Dict,
     Iterator,
-    List,
-    Optional,
 )
 
 from eth_typing import (
@@ -17,9 +14,9 @@ from web3.utils import (
 
 class SubscriptionContainer:
     def __init__(self) -> None:
-        self.subscriptions: List[EthSubscription[Any]] = []
-        self.subscriptions_by_id: Dict[HexStr, EthSubscription[Any]] = {}
-        self.subscriptions_by_label: Dict[str, EthSubscription[Any]] = {}
+        self.subscriptions: list[EthSubscription[Any]] = []
+        self.subscriptions_by_id: dict[HexStr, EthSubscription[Any]] = {}
+        self.subscriptions_by_label: dict[str, EthSubscription[Any]] = {}
 
     def __len__(self) -> int:
         return len(self.subscriptions)
@@ -44,12 +41,12 @@ class SubscriptionContainer:
         return self.subscriptions_by_label.get(label)
 
     @property
-    def handler_subscriptions(self) -> List[EthSubscription[Any]]:
+    def handler_subscriptions(self) -> list[EthSubscription[Any]]:
         return [sub for sub in self.subscriptions if sub._handler is not None]
 
     def get_handler_subscription_by_id(
         self, sub_id: HexStr
-    ) -> Optional[EthSubscription[Any]]:
+    ) -> EthSubscription[Any] | None:
         sub = self.get_by_id(sub_id)
         if sub and sub._handler:
             return sub

web3/providers/persistent/subscription_manager.py

@@ -3,10 +3,7 @@ import logging
 from typing import (
     TYPE_CHECKING,
     Any,
-    List,
     Sequence,
-    Set,
-    Union,
     cast,
     overload,
 )
@@ -61,8 +58,7 @@ class SubscriptionManager:
         # parallelize all subscription handler calls
         self.parallelize = False
         self.task_timeout = 1
-        # TODO: can remove quotes from type hints once Python 3.8 support is dropped
-        self._tasks: Set["asyncio.Task[None]"] = set()
+        self._tasks: set[asyncio.Task[None]] = set()
 
         # share the subscription container with the request processor so it can separate
         # subscriptions into different queues based on ``sub._handler`` presence
@@ -95,8 +91,7 @@ class SubscriptionManager:
                     f"labels.\n    label: {subscription._label}"
                 )
 
-    # TODO: can remove quotes from type hints once Python 3.8 support is dropped
-    def _handler_task_callback(self, task: "asyncio.Task[None]") -> None:
+    def _handler_task_callback(self, task: asyncio.Task[None]) -> None:
         """
         Callback when a handler task completes. Similar to _message_listener_callback.
         Puts handler exceptions into the queue to be raised in the main loop, else
@@ -125,7 +120,7 @@ class SubscriptionManager:
         self._tasks.clear()
 
     @property
-    def subscriptions(self) -> List[EthSubscription[Any]]:
+    def subscriptions(self) -> list[EthSubscription[Any]]:
         return self._subscription_container.subscriptions
 
     def get_by_id(self, sub_id: HexStr) -> EthSubscription[Any]:
@@ -141,12 +136,13 @@ class SubscriptionManager:
     @overload
     async def subscribe(
         self, subscriptions: Sequence[EthSubscription[Any]]
-    ) -> List[HexStr]:
+    ) -> list[HexStr]:
         ...
 
     async def subscribe(
-        self, subscriptions: Union[EthSubscription[Any], Sequence[EthSubscription[Any]]]
-    ) -> Union[HexStr, List[HexStr]]:
+        self,
+        subscriptions: EthSubscription[Any] | Sequence[EthSubscription[Any]],
+    ) -> HexStr | list[HexStr]:
         """
         Used to subscribe to a single or multiple subscriptions.
 
@@ -170,7 +166,7 @@ class SubscriptionManager:
             if len(subscriptions) == 0:
                 raise Web3ValueError("No subscriptions provided.")
 
-            sub_ids: List[HexStr] = []
+            sub_ids: list[HexStr] = []
             for sub in subscriptions:
                 sub_ids.append(await self.subscribe(sub))
             return sub_ids
@@ -187,17 +183,15 @@ class SubscriptionManager:
     @overload
     async def unsubscribe(
         self,
-        subscriptions: Sequence[Union[EthSubscription[Any], HexStr]],
+        subscriptions: Sequence[EthSubscription[Any] | HexStr],
     ) -> bool:
         ...
 
     async def unsubscribe(
         self,
-        subscriptions: Union[
-            EthSubscription[Any],
-            HexStr,
-            Sequence[Union[EthSubscription[Any], HexStr]],
-        ],
+        subscriptions: (
+            EthSubscription[Any] | HexStr | Sequence[EthSubscription[Any] | HexStr]
+        ),
     ) -> bool:
         """
         Used to unsubscribe from one or multiple subscriptions.
@@ -246,7 +240,7 @@ class SubscriptionManager:
             if len(subscriptions) == 0:
                 raise Web3ValueError("No subscriptions provided.")
 
-            unsubscribed: List[bool] = []
+            unsubscribed: list[bool] = []
             # re-create the subscription list to prevent modifying the original list
             # in case ``subscription_manager.subscriptions`` was passed in directly
             subs = list(subscriptions)