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

web3/_utils/formatters.py

@@ -1,13 +1,8 @@
-from collections.abc import (
-    Mapping,
-)
 from typing import (
     Any,
     Callable,
-    Dict,
     Iterable,
-    Optional,
-    Tuple,
+    Mapping,
     TypeVar,
 )
 
@@ -97,8 +92,8 @@ def static_return(value: TValue) -> Callable[..., TValue]:
     return inner
 
 
-def static_result(value: TValue) -> Callable[..., Dict[str, TValue]]:
-    def inner(*args: Any, **kwargs: Any) -> Dict[str, TValue]:
+def static_result(value: TValue) -> Callable[..., dict[str, TValue]]:
+    def inner(*args: Any, **kwargs: Any) -> dict[str, TValue]:
         return {"result": value}
 
     return inner
@@ -107,8 +102,8 @@ def static_result(value: TValue) -> Callable[..., Dict[str, TValue]]:
 @curry
 @to_dict
 def apply_key_map(
-    key_mappings: Dict[Any, Any], value: Dict[Any, Any]
-) -> Iterable[Tuple[Any, Any]]:
+    key_mappings: dict[Any, Any], value: dict[Any, Any]
+) -> Iterable[tuple[Any, Any]]:
     for key, item in value.items():
         if key in key_mappings:
             yield key_mappings[key], item
@@ -130,8 +125,8 @@ def is_array_of_dicts(value: Any) -> bool:
 
 @curry
 def remove_key_if(
-    key: Any, remove_if: Callable[[Dict[Any, Any]], bool], input_dict: Dict[Any, Any]
-) -> Dict[Any, Any]:
+    key: Any, remove_if: Callable[[dict[Any, Any]], bool], input_dict: dict[Any, Any]
+) -> dict[Any, Any]:
     if key in input_dict and remove_if(input_dict):
         return dissoc(input_dict, key)
     else:
@@ -152,7 +147,7 @@ def apply_error_formatters(
 def apply_null_result_formatters(
     null_result_formatters: Callable[..., Any],
     response: RPCResponse,
-    params: Optional[Any] = None,
+    params: Any | None = None,
 ) -> RPCResponse:
     if null_result_formatters:
         formatted_resp = pipe(params, null_result_formatters)

web3/_utils/http_session_manager.py

@@ -8,10 +8,6 @@ import threading
 import time
 from typing import (
     Any,
-    Dict,
-    List,
-    Optional,
-    Union,
 )
 
 from aiohttp import (
@@ -50,11 +46,9 @@ class HTTPSessionManager:
         self,
         cache_size: int = 100,
         session_pool_max_workers: int = 5,
-        explicit_session: Optional[requests.Session] = None,
     ) -> None:
         self.session_cache = SimpleCache(cache_size)
         self.session_pool = ThreadPoolExecutor(max_workers=session_pool_max_workers)
-        self._explicit_session = explicit_session
 
     @staticmethod
     def get_default_http_endpoint() -> URI:
@@ -64,13 +58,8 @@ class HTTPSessionManager:
         self,
         endpoint_uri: URI,
         session: requests.Session = None,
-        request_timeout: Optional[float] = None,
+        request_timeout: float | None = None,
     ) -> requests.Session:
-        # If an explicit session was provided at init time, always use it
-        # regardless of which thread is making the request
-        if self._explicit_session is not None:
-            return self._explicit_session
-
         # cache key should have a unique thread identifier
         cache_key = generate_cache_key(f"{threading.get_ident()}:{endpoint_uri}")
 
@@ -119,7 +108,7 @@ class HTTPSessionManager:
 
     def json_make_get_request(
         self, endpoint_uri: URI, *args: Any, **kwargs: Any
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         response = self.get_response_from_get_request(endpoint_uri, *args, **kwargs)
         response.raise_for_status()
         return response.json()
@@ -135,13 +124,13 @@ class HTTPSessionManager:
 
     def json_make_post_request(
         self, endpoint_uri: URI, *args: Any, **kwargs: Any
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         response = self.get_response_from_post_request(endpoint_uri, *args, **kwargs)
         response.raise_for_status()
         return response.json()
 
     def make_post_request(
-        self, endpoint_uri: URI, data: Union[bytes, Dict[str, Any]], **kwargs: Any
+        self, endpoint_uri: URI, data: bytes | dict[str, Any], **kwargs: Any
     ) -> bytes:
         kwargs.setdefault("timeout", DEFAULT_HTTP_TIMEOUT)
         kwargs.setdefault("stream", False)
@@ -171,7 +160,7 @@ class HTTPSessionManager:
                 raise TimeExhausted
         return response_body
 
-    def _close_evicted_sessions(self, evicted_sessions: List[requests.Session]) -> None:
+    def _close_evicted_sessions(self, evicted_sessions: list[requests.Session]) -> None:
         for evicted_session in evicted_sessions:
             evicted_session.close()
             self.logger.debug("Closed evicted session: %s", evicted_session)
@@ -181,8 +170,8 @@ class HTTPSessionManager:
     async def async_cache_and_return_session(
         self,
         endpoint_uri: URI,
-        session: Optional[ClientSession] = None,
-        request_timeout: Optional[ClientTimeout] = None,
+        session: ClientSession | None = None,
+        request_timeout: ClientTimeout | None = None,
     ) -> ClientSession:
         # cache key should have a unique thread identifier
         cache_key = generate_cache_key(f"{id(asyncio.get_event_loop())}:{endpoint_uri}")
@@ -291,7 +280,7 @@ class HTTPSessionManager:
 
     async def async_json_make_get_request(
         self, endpoint_uri: URI, *args: Any, **kwargs: Any
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         response = await self.async_get_response_from_get_request(
             endpoint_uri, *args, **kwargs
         )
@@ -310,7 +299,7 @@ class HTTPSessionManager:
 
     async def async_json_make_post_request(
         self, endpoint_uri: URI, *args: Any, **kwargs: Any
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         response = await self.async_get_response_from_post_request(
             endpoint_uri, *args, **kwargs
         )
@@ -318,7 +307,7 @@ class HTTPSessionManager:
         return await response.json()
 
     async def async_make_post_request(
-        self, endpoint_uri: URI, data: Union[bytes, Dict[str, Any]], **kwargs: Any
+        self, endpoint_uri: URI, data: bytes | dict[str, Any], **kwargs: Any
     ) -> bytes:
         response = await self.async_get_response_from_post_request(
             endpoint_uri, data=data, **kwargs
@@ -327,7 +316,7 @@ class HTTPSessionManager:
         return await response.read()
 
     async def _async_close_evicted_sessions(
-        self, timeout: float, evicted_sessions: List[ClientSession]
+        self, timeout: float, evicted_sessions: list[ClientSession]
     ) -> None:
         await asyncio.sleep(timeout)
 

web3/_utils/math.py

@@ -1,5 +1,4 @@
 from typing import (
-    Optional,
     Sequence,
 )
 
@@ -10,7 +9,7 @@ from web3.exceptions import (
 
 
 def percentile(
-    values: Optional[Sequence[int]] = None, percentile: Optional[float] = None
+    values: Sequence[int] | None = None, percentile: float | None = None
 ) -> float:
     """Calculates a simplified weighted average percentile"""
     if values in [None, tuple(), []] or len(values) < 1:

web3/_utils/method_formatters.py

@@ -5,10 +5,8 @@ from typing import (
     Any,
     Callable,
     Collection,
-    Dict,
     Iterable,
     NoReturn,
-    Tuple,
     TypeVar,
     Union,
     cast,
@@ -136,7 +134,7 @@ is_not_null = complement(is_null)
 
 @curry
 def to_hexbytes(
-    num_bytes: int, val: Union[str, int, bytes], variable_length: bool = False
+    num_bytes: int, val: str | int | bytes, variable_length: bool = False
 ) -> HexBytes:
     if isinstance(val, (str, int, bytes)):
         result = HexBytes(val)
@@ -161,8 +159,8 @@ def is_attrdict(val: Any) -> bool:
 @curry
 def type_aware_apply_formatters_to_dict(
     formatters: Formatters,
-    value: Union[AttributeDict[str, Any], Dict[str, Any]],
-) -> Union[ReadableAttributeDict[str, Any], Dict[str, Any]]:
+    value: AttributeDict[str, Any] | dict[str, Any],
+) -> ReadableAttributeDict[str, Any] | dict[str, Any]:
     """
     Preserve ``AttributeDict`` types if original ``value`` was an ``AttributeDict``.
     """
@@ -172,7 +170,7 @@ def type_aware_apply_formatters_to_dict(
     if isinstance(value, BaseModel):
         value = value.model_dump(by_alias=True)
 
-    formatted_dict: Dict[str, Any] = apply_formatters_to_dict(formatters, dict(value))
+    formatted_dict: dict[str, Any] = apply_formatters_to_dict(formatters, dict(value))
     return (
         AttributeDict.recursive(formatted_dict)
         if is_attrdict(value)
@@ -183,8 +181,8 @@ def type_aware_apply_formatters_to_dict(
 def type_aware_apply_formatters_to_dict_keys_and_values(
     key_formatters: Callable[[Any], Any],
     value_formatters: Callable[[Any], Any],
-    dict_like_object: Union[AttributeDict[str, Any], Dict[str, Any]],
-) -> Union[ReadableAttributeDict[str, Any], Dict[str, Any]]:
+    dict_like_object: AttributeDict[str, Any] | dict[str, Any],
+) -> ReadableAttributeDict[str, Any] | dict[str, Any]:
     """
     Preserve ``AttributeDict`` types if original ``value`` was an ``AttributeDict``.
     """
@@ -205,7 +203,7 @@ def apply_list_to_array_formatter(formatter: Any) -> Callable[..., Any]:
     return to_list(apply_formatter_to_array(formatter))
 
 
-def storage_key_to_hexstr(value: Union[bytes, int, str]) -> HexStr:
+def storage_key_to_hexstr(value: bytes | int | str) -> HexStr:
     if not isinstance(value, (bytes, int, str)):
         raise Web3ValueError(
             f"Storage key must be one of bytes, int, str, got {type(value)}"
@@ -555,7 +553,7 @@ transaction_param_formatter = compose(
 
 
 call_without_override: Callable[
-    [Tuple[TxParams, BlockIdentifier]], Tuple[Dict[str, Any], int]
+    [tuple[TxParams, BlockIdentifier]], tuple[dict[str, Any], int]
 ] = apply_formatters_to_sequence(
     [
         transaction_param_formatter,
@@ -573,8 +571,8 @@ state_override_formatter = type_aware_apply_formatters_to_dict(
 )
 
 call_with_override: Callable[
-    [Tuple[TxParams, BlockIdentifier, StateOverrideParams]],
-    Tuple[Dict[str, Any], int, Dict[str, Any]],
+    [tuple[TxParams, BlockIdentifier, StateOverrideParams]],
+    tuple[dict[str, Any], int, dict[str, Any]],
 ] = apply_formatters_to_sequence(
     [
         transaction_param_formatter,
@@ -589,10 +587,10 @@ call_with_override: Callable[
 
 
 estimate_gas_without_block_id: Callable[
-    [Dict[str, Any]], Dict[str, Any]
+    [dict[str, Any]], dict[str, Any]
 ] = apply_formatter_at_index(transaction_param_formatter, 0)
 estimate_gas_with_block_id: Callable[
-    [Tuple[Dict[str, Any], BlockIdentifier]], Tuple[Dict[str, Any], int]
+    [tuple[dict[str, Any], BlockIdentifier]], tuple[dict[str, Any], int]
 ] = apply_formatters_to_sequence(
     [
         transaction_param_formatter,
@@ -600,8 +598,8 @@ estimate_gas_with_block_id: Callable[
     ]
 )
 estimate_gas_with_override: Callable[
-    [Tuple[Dict[str, Any], BlockIdentifier, StateOverrideParams]],
-    Tuple[Dict[str, Any], int, Dict[str, Any]],
+    [tuple[dict[str, Any], BlockIdentifier, StateOverrideParams]],
+    tuple[dict[str, Any], int, dict[str, Any]],
 ] = apply_formatters_to_sequence(
     [
         transaction_param_formatter,
@@ -617,7 +615,7 @@ estimate_gas_with_override: Callable[
 # -- eth_simulateV1 -- #
 
 block_state_calls_formatter: Callable[
-    [Dict[str, Any]], Dict[str, Any]
+    [dict[str, Any]], dict[str, Any]
 ] = apply_formatter_to_array(
     apply_formatters_to_dict(
         {
@@ -635,8 +633,8 @@ block_state_calls_formatter: Callable[
 )
 
 simulate_v1_request_formatter: Callable[
-    [Tuple[Dict[str, Any], bool, bool], BlockIdentifier],
-    Tuple[SimulateV1Payload, BlockIdentifier],
+    [tuple[dict[str, Any], bool, bool], BlockIdentifier],
+    tuple[SimulateV1Payload, BlockIdentifier],
 ] = apply_formatters_to_sequence(
     [
         # payload
@@ -691,7 +689,7 @@ GETH_WALLETS_FORMATTER = {
 
 geth_wallets_formatter = type_aware_apply_formatters_to_dict(GETH_WALLETS_FORMATTER)
 
-PYTHONIC_REQUEST_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
+PYTHONIC_REQUEST_FORMATTERS: dict[RPCEndpoint, Callable[..., Any]] = {
     # Eth
     RPC.eth_feeHistory: compose(
         apply_formatter_at_index(to_hex_if_integer, 0),
@@ -795,8 +793,8 @@ def has_pretrace_keys(val: Any) -> bool:
 
 @curry
 def pretrace_formatter(
-    resp: Union[AttributeDict[str, Any], Dict[str, Any]],
-) -> Union[ReadableAttributeDict[str, Any], Dict[str, Any]]:
+    resp: AttributeDict[str, Any] | dict[str, Any],
+) -> ReadableAttributeDict[str, Any] | dict[str, Any]:
     return type_aware_apply_formatters_to_dict_keys_and_values(
         apply_formatter_if(is_address, to_checksum_address),
         apply_formatter_if(
@@ -892,7 +890,7 @@ TRACE_RESULT_FORMATTERS = apply_formatter_if(
 )
 
 # result formatters for the trace field
-TRACE_FORMATTERS: Callable[[TValue], Union[Any, TValue]] = apply_formatter_if(
+TRACE_FORMATTERS: Callable[[TValue], Any | TValue] = apply_formatter_if(
     is_not_null,
     type_aware_apply_formatters_to_dict(
         {
@@ -921,7 +919,7 @@ common_tracing_result_formatter = type_aware_apply_formatters_to_dict(
 
 
 # -- eth_subscribe -- #
-def subscription_formatter(value: Any) -> Union[HexBytes, HexStr, Dict[str, Any]]:
+def subscription_formatter(value: Any) -> HexBytes | HexStr | dict[str, Any]:
     if is_hexstr(value):
         # subscription id from the original subscription request
         return HexStr(value)
@@ -980,7 +978,7 @@ def subscription_formatter(value: Any) -> Union[HexBytes, HexStr, Dict[str, Any]
     return value
 
 
-PYTHONIC_RESULT_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
+PYTHONIC_RESULT_FORMATTERS: dict[RPCEndpoint, Callable[..., Any]] = {
     # Eth
     RPC.eth_accounts: apply_list_to_array_formatter(to_checksum_address),
     RPC.eth_blobBaseFee: to_integer_if_hex,
@@ -1068,7 +1066,7 @@ PYTHONIC_RESULT_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
     ),
 }
 
-METHOD_NORMALIZERS: Dict[RPCEndpoint, Callable[..., Any]] = {
+METHOD_NORMALIZERS: dict[RPCEndpoint, Callable[..., Any]] = {
     RPC.eth_getLogs: apply_formatter_at_index(FILTER_PARAM_NORMALIZERS, 0),
     RPC.eth_newFilter: apply_formatter_at_index(FILTER_PARAM_NORMALIZERS, 0),
 }
@@ -1086,7 +1084,7 @@ ABI_REQUEST_FORMATTERS: Formatters = abi_request_formatters(
 )
 
 
-ERROR_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
+ERROR_FORMATTERS: dict[RPCEndpoint, Callable[..., Any]] = {
     RPC.eth_estimateGas: raise_contract_logic_error_on_revert,
     RPC.eth_call: raise_contract_logic_error_on_revert,
     RPC.eth_getTransactionReceipt: raise_transaction_indexing_error_if_indexing,
@@ -1096,7 +1094,7 @@ ERROR_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
 
 @to_tuple
 def combine_formatters(
-    formatter_maps: Collection[Dict[RPCEndpoint, Callable[..., TReturn]]],
+    formatter_maps: Collection[dict[RPCEndpoint, Callable[..., TReturn]]],
     method_name: RPCEndpoint,
 ) -> Iterable[Callable[..., TReturn]]:
     for formatter_map in formatter_maps:
@@ -1118,7 +1116,7 @@ def get_request_formatters(method_name: RPCEndpoint) -> Callable[[RPCResponse],
     return compose(*formatters)
 
 
-def raise_block_not_found(params: Tuple[BlockIdentifier, bool]) -> NoReturn:
+def raise_block_not_found(params: tuple[BlockIdentifier, bool]) -> NoReturn:
     try:
         block_identifier = params[0]
         message = f"Block with id: {block_identifier!r} not found."
@@ -1129,7 +1127,7 @@ def raise_block_not_found(params: Tuple[BlockIdentifier, bool]) -> NoReturn:
 
 
 def raise_block_not_found_for_uncle_at_index(
-    params: Tuple[BlockIdentifier, Union[HexStr, int]],
+    params: tuple[BlockIdentifier, HexStr | int],
 ) -> NoReturn:
     try:
         block_identifier = params[0]
@@ -1144,7 +1142,7 @@ def raise_block_not_found_for_uncle_at_index(
     raise BlockNotFound(message)
 
 
-def raise_transaction_not_found(params: Tuple[_Hash32]) -> NoReturn:
+def raise_transaction_not_found(params: tuple[_Hash32]) -> NoReturn:
     try:
         transaction_hash = params[0]
         message = f"Transaction with hash: {transaction_hash!r} not found."
@@ -1155,7 +1153,7 @@ def raise_transaction_not_found(params: Tuple[_Hash32]) -> NoReturn:
 
 
 def raise_transaction_not_found_with_index(
-    params: Tuple[BlockIdentifier, int],
+    params: tuple[BlockIdentifier, int],
 ) -> NoReturn:
     try:
         block_identifier = params[0]
@@ -1170,7 +1168,7 @@ def raise_transaction_not_found_with_index(
     raise TransactionNotFound(message)
 
 
-NULL_RESULT_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
+NULL_RESULT_FORMATTERS: dict[RPCEndpoint, Callable[..., Any]] = {
     RPC.eth_getBlockByHash: raise_block_not_found,
     RPC.eth_getBlockByNumber: raise_block_not_found,
     RPC.eth_getBlockReceipts: raise_block_not_found,
@@ -1194,14 +1192,14 @@ def filter_wrapper(
     module: Union["AsyncEth", "Eth"],
     method: RPCEndpoint,
     filter_id: HexStr,
-) -> Union[
-    AsyncBlockFilter,
-    AsyncTransactionFilter,
-    AsyncLogFilter,
-    BlockFilter,
-    TransactionFilter,
-    LogFilter,
-]:
+) -> (
+    AsyncBlockFilter
+    | AsyncTransactionFilter
+    | AsyncLogFilter
+    | BlockFilter
+    | TransactionFilter
+    | LogFilter
+):
     if method == RPC.eth_newBlockFilter:
         if module.is_async:
             return AsyncBlockFilter(filter_id, eth_module=cast("AsyncEth", module))
@@ -1227,7 +1225,7 @@ def filter_wrapper(
         )
 
 
-FILTER_RESULT_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
+FILTER_RESULT_FORMATTERS: dict[RPCEndpoint, Callable[..., Any]] = {
     RPC.eth_newPendingTransactionFilter: filter_wrapper,
     RPC.eth_newBlockFilter: filter_wrapper,
     RPC.eth_newFilter: filter_wrapper,
@@ -1238,7 +1236,7 @@ FILTER_RESULT_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
 def apply_module_to_formatters(
     formatters: Iterable[Callable[..., TReturn]],
     module: "Module",
-    method_name: Union[RPCEndpoint, Callable[..., RPCEndpoint]],
+    method_name: RPCEndpoint | Callable[..., RPCEndpoint],
 ) -> Iterable[Callable[..., TReturn]]:
     for f in formatters:
         yield partial(f, module, method_name)

web3/_utils/module.py

@@ -5,9 +5,6 @@ from io import (
 from typing import (
     TYPE_CHECKING,
     Any,
-    Dict,
-    List,
-    Optional,
     Sequence,
     Union,
 )
@@ -24,7 +21,7 @@ if TYPE_CHECKING:
     from web3.main import BaseWeb3  # noqa: F401
 
 
-def _validate_init_params_and_return_if_found(module_class: Any) -> List[str]:
+def _validate_init_params_and_return_if_found(module_class: Any) -> list[str]:
     init_params_raw = list(inspect.signature(module_class.__init__).parameters)
     module_init_params = [
         param for param in init_params_raw if param not in ["self", "args", "kwargs"]
@@ -42,8 +39,8 @@ def _validate_init_params_and_return_if_found(module_class: Any) -> List[str]:
 
 def attach_modules(
     parent_module: Union["BaseWeb3", "Module"],
-    module_definitions: Dict[str, Any],
-    w3: Optional[Union["BaseWeb3", "Module"]] = None,
+    module_definitions: dict[str, Any],
+    w3: Union["BaseWeb3", "Module"] | None = None,
 ) -> None:
     for module_name, module_info in module_definitions.items():
         module_info_is_list_like = isinstance(module_info, Sequence)

web3/_utils/module_testing/eth_module.py

@@ -10,8 +10,6 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
-    List,
-    Type,
     Union,
     cast,
 )
@@ -660,7 +658,7 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_ExtraDataToPOAMiddleware(
-        self, async_w3: "AsyncWeb3[Any]", request_mocker: Type[RequestMocker]
+        self, async_w3: "AsyncWeb3[Any]", request_mocker: type[RequestMocker]
     ) -> None:
         async_w3.middleware_onion.inject(ExtraDataToPOAMiddleware, "poa", layer=0)
         extra_data = f"0x{'ff' * 33}"
@@ -1011,7 +1009,7 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_eth_max_priority_fee_with_fee_history_calculation(
-        self, async_w3: "AsyncWeb3[Any]", request_mocker: Type[RequestMocker]
+        self, async_w3: "AsyncWeb3[Any]", request_mocker: type[RequestMocker]
     ) -> None:
         async with request_mocker(
             async_w3,
@@ -1206,7 +1204,7 @@ class AsyncEthModuleTest:
     async def test_eth_get_raw_transaction_by_block_raises_error(
         self,
         async_w3: "AsyncWeb3[Any]",
-        unknown_block_num_or_hash: Union[int, HexBytes],
+        unknown_block_num_or_hash: int | HexBytes,
     ) -> None:
         with pytest.raises(
             TransactionNotFound,
@@ -1519,7 +1517,7 @@ class AsyncEthModuleTest:
         async_w3: "AsyncWeb3[Any]",
         async_panic_errors_contract: "AsyncContract",
         panic_error: str,
-        params: List[Any],
+        params: list[Any],
     ) -> None:
         method = getattr(
             async_panic_errors_contract.functions,
@@ -2697,7 +2695,7 @@ class EthModuleTest:
         assert is_integer(max_priority_fee)
 
     def test_eth_max_priority_fee_with_fee_history_calculation(
-        self, w3: "Web3", request_mocker: Type[RequestMocker]
+        self, w3: "Web3", request_mocker: type[RequestMocker]
     ) -> None:
         with request_mocker(
             w3,
@@ -4171,7 +4169,7 @@ class EthModuleTest:
         w3: "Web3",
         panic_errors_contract: "Contract",
         panic_error: str,
-        params: List[Any],
+        params: list[Any],
     ) -> None:
         method = getattr(
             panic_errors_contract.functions,
@@ -5016,7 +5014,7 @@ class EthModuleTest:
 
     @pytest.mark.parametrize("unknown_block_num_or_hash", (1234567899999, UNKNOWN_HASH))
     def test_eth_get_raw_transaction_by_block_raises_error(
-        self, w3: "Web3", unknown_block_num_or_hash: Union[int, HexBytes]
+        self, w3: "Web3", unknown_block_num_or_hash: int | HexBytes
     ) -> None:
         with pytest.raises(
             TransactionNotFound,

web3/_utils/module_testing/go_ethereum_admin_module.py

@@ -2,7 +2,6 @@ import pytest
 from typing import (
     TYPE_CHECKING,
     Any,
-    List,
 )
 
 from web3.datastructures import (
@@ -83,7 +82,7 @@ class GoEthereumAsyncAdminModuleTest:
     @pytest.mark.asyncio
     async def test_async_nodes(self, async_w3: "AsyncWeb3[Any]") -> None:
         nodes = await async_w3.geth.admin.peers()
-        assert isinstance(nodes, List)
+        assert isinstance(nodes, list)
 
     @pytest.mark.asyncio
     async def test_admin_peers(self, async_w3: "AsyncWeb3[Any]") -> None:

web3/_utils/module_testing/module_testing_utils.py

@@ -3,7 +3,6 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Collection,
-    Dict,
     Generator,
     Literal,
     Sequence,
@@ -25,6 +24,9 @@ from hexbytes import (
     HexBytes,
 )
 import requests
+from websockets.protocol import (
+    State,
+)
 
 from web3._utils.http import (
     DEFAULT_HTTP_TIMEOUT,
@@ -77,7 +79,7 @@ def mock_offchain_lookup_request_response(
         status_code = mocked_status_code
 
         @staticmethod
-        def json() -> Dict[str, str]:
+        def json() -> dict[str, str]:
             return {json_data_field: mocked_json_data}  # noqa: E704
 
         @staticmethod
@@ -127,7 +129,7 @@ def async_mock_offchain_lookup_request_response(
             return self
 
         @staticmethod
-        async def json() -> Dict[str, str]:
+        async def json() -> dict[str, str]:
             return {json_data_field: mocked_json_data}  # noqa: E704
 
         @staticmethod
@@ -160,10 +162,12 @@ def async_mock_offchain_lookup_request_response(
 
 
 class WebSocketMessageStreamMock:
-    closed: bool = False
+    state: State = State.OPEN
 
     def __init__(
-        self, messages: Collection[bytes] = None, raise_exception: Exception = None
+        self,
+        messages: Collection[bytes] = None,
+        raise_exception: Exception = None,
     ) -> None:
         self.queue = asyncio.Queue()  # type: ignore  # py38 issue
         for msg in messages or []:

web3/_utils/module_testing/persistent_connection_provider.py

@@ -6,12 +6,8 @@ from dataclasses import (
 from typing import (
     TYPE_CHECKING,
     Any,
-    Dict,
     Generator,
-    List,
     Sequence,
-    Tuple,
-    Union,
     cast,
 )
 
@@ -306,8 +302,8 @@ class PersistentConnectionProviderTest:
     async def test_async_eth_subscribe_syncing_mocked(
         self,
         async_w3: "AsyncWeb3[Any]",
-        subscription_params: Tuple[Any, ...],
-        ws_subscription_response: Dict[str, Any],
+        subscription_params: tuple[Any, ...],
+        ws_subscription_response: dict[str, Any],
         expected_formatted_result: Any,
     ) -> None:
         sub_id = await async_w3.eth.subscribe(*subscription_params)
@@ -966,7 +962,7 @@ class PersistentConnectionProviderTest:
         async_w3: "AsyncWeb3[Any]",
     ) -> None:
         async def unsubscribe_subs(
-            subs: List[Union[NewHeadsSubscription, LogsSubscription]],
+            subs: list[NewHeadsSubscription | LogsSubscription],
         ) -> None:
             for sub in subs:
                 await sub.unsubscribe()