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

web3/middleware/filter.py

@@ -5,13 +5,9 @@ from typing import (
     Any,
     AsyncIterable,
     AsyncIterator,
-    Dict,
     Generator,
     Iterable,
     Iterator,
-    List,
-    Optional,
-    Tuple,
     Union,
     cast,
 )
@@ -73,7 +69,7 @@ else:
     MAX_BLOCK_REQUEST = 50
 
 
-def segment_count(start: int, stop: int, step: int = 5) -> Iterable[Tuple[int, int]]:
+def segment_count(start: int, stop: int, step: int = 5) -> Iterable[tuple[int, int]]:
     """
     Creates a segment counting generator
 
@@ -104,7 +100,7 @@ def segment_count(start: int, stop: int, step: int = 5) -> Iterable[Tuple[int, i
     return gen_bounded_segments(start, stop, step)
 
 
-def gen_bounded_segments(start: int, stop: int, step: int) -> Iterable[Tuple[int, int]]:
+def gen_bounded_segments(start: int, stop: int, step: int) -> Iterable[tuple[int, int]]:
     #  If the initial range is less than the step
     #  just return (start, stop)
     if start + step >= stop:
@@ -121,8 +117,8 @@ def gen_bounded_segments(start: int, stop: int, step: int) -> Iterable[Tuple[int
 
 
 def block_ranges(
-    start_block: BlockNumber, last_block: Optional[BlockNumber], step: int = 5
-) -> Iterable[Tuple[BlockNumber, BlockNumber]]:
+    start_block: BlockNumber, last_block: BlockNumber | None, step: int = 5
+) -> Iterable[tuple[BlockNumber, BlockNumber]]:
     """
     Returns 2-tuple ranges describing ranges of block from start_block to last_block
 
@@ -142,7 +138,7 @@ def block_ranges(
 
 
 def iter_latest_block(
-    w3: "Web3", to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None
+    w3: "Web3", to_block: BlockNumber | LatestBlockParam | None = None
 ) -> Iterable[BlockNumber]:
     """
     Returns a generator that dispenses the latest block, if
@@ -180,8 +176,8 @@ def iter_latest_block(
 def iter_latest_block_ranges(
     w3: "Web3",
     from_block: BlockNumber,
-    to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None,
-) -> Iterable[Tuple[Optional[BlockNumber], Optional[BlockNumber]]]:
+    to_block: BlockNumber | LatestBlockParam | None = None,
+) -> Iterable[tuple[BlockNumber | None, BlockNumber | None]]:
     """
     Returns an iterator unloading ranges of available blocks
 
@@ -207,7 +203,7 @@ def iter_latest_block_ranges(
             from_block = BlockNumber(latest_block + 1)
 
 
-def drop_items_with_none_value(params: Dict[str, Any]) -> Dict[str, Any]:
+def drop_items_with_none_value(params: dict[str, Any]) -> dict[str, Any]:
     return valfilter(lambda x: x is not None, params)
 
 
@@ -215,10 +211,10 @@ def get_logs_multipart(
     w3: "Web3",
     start_block: BlockNumber,
     stop_block: BlockNumber,
-    address: Union[Address, ChecksumAddress, List[Union[Address, ChecksumAddress]]],
-    topics: List[Optional[Union[_Hash32, List[_Hash32]]]],
+    address: Address | ChecksumAddress | list[Address | ChecksumAddress],
+    topics: list[_Hash32 | list[_Hash32] | None],
     max_blocks: int,
-) -> Iterable[List[LogReceipt]]:
+) -> Iterable[list[LogReceipt]]:
     """
     Used to break up requests to ``eth_getLogs``
 
@@ -242,12 +238,11 @@ class RequestLogs:
     def __init__(
         self,
         w3: "Web3",
-        from_block: Optional[Union[BlockNumber, LatestBlockParam]] = None,
-        to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None,
-        address: Optional[
-            Union[Address, ChecksumAddress, List[Union[Address, ChecksumAddress]]]
-        ] = None,
-        topics: Optional[List[Optional[Union[_Hash32, List[_Hash32]]]]] = None,
+        from_block: BlockNumber | LatestBlockParam | None = None,
+        to_block: BlockNumber | LatestBlockParam | None = None,
+        address: None
+        | (Address | ChecksumAddress | list[Address | ChecksumAddress]) = None,
+        topics: list[_Hash32 | list[_Hash32] | None] | None = None,
     ) -> None:
         self.address = address
         self.topics = topics
@@ -278,7 +273,7 @@ class RequestLogs:
 
         return to_block
 
-    def _get_filter_changes(self) -> Iterator[List[LogReceipt]]:
+    def _get_filter_changes(self) -> Iterator[list[LogReceipt]]:
         for start, stop in iter_latest_block_ranges(
             self.w3, self.from_block, self.to_block
         ):
@@ -298,7 +293,7 @@ class RequestLogs:
                     )
                 )
 
-    def get_logs(self) -> List[LogReceipt]:
+    def get_logs(self) -> list[LogReceipt]:
         return list(
             concat(
                 get_logs_multipart(
@@ -332,10 +327,10 @@ class RequestBlocks:
         self.start_block = BlockNumber(w3.eth.block_number + 1)
 
     @property
-    def filter_changes(self) -> Iterator[List[Hash32]]:
+    def filter_changes(self) -> Iterator[list[Hash32]]:
         return self.get_filter_changes()
 
-    def get_filter_changes(self) -> Iterator[List[Hash32]]:
+    def get_filter_changes(self) -> Iterator[list[Hash32]]:
         block_range_iter = iter_latest_block_ranges(self.w3, self.start_block, None)
 
         for block_range in block_range_iter:
@@ -344,7 +339,7 @@ class RequestBlocks:
 
 @to_list
 def block_hashes_in_range(
-    w3: "Web3", block_range: Tuple[BlockNumber, BlockNumber]
+    w3: "Web3", block_range: tuple[BlockNumber, BlockNumber]
 ) -> Iterable[Hash32]:
     from_block, to_block = block_range
     if from_block is None or to_block is None:
@@ -358,7 +353,7 @@ def block_hashes_in_range(
 
 async def async_iter_latest_block(
     w3: "AsyncWeb3[Any]",
-    to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None,
+    to_block: BlockNumber | LatestBlockParam | None = None,
 ) -> AsyncIterable[BlockNumber]:
     """
     Returns a generator that dispenses the latest block, if
@@ -397,8 +392,8 @@ async def async_iter_latest_block(
 async def async_iter_latest_block_ranges(
     w3: "AsyncWeb3[Any]",
     from_block: BlockNumber,
-    to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None,
-) -> AsyncIterable[Tuple[Optional[BlockNumber], Optional[BlockNumber]]]:
+    to_block: BlockNumber | LatestBlockParam | None = None,
+) -> AsyncIterable[tuple[BlockNumber | None, BlockNumber | None]]:
     """
     Returns an iterator unloading ranges of available blocks
 
@@ -429,10 +424,10 @@ async def async_get_logs_multipart(
     w3: "AsyncWeb3[Any]",
     start_block: BlockNumber,
     stop_block: BlockNumber,
-    address: Union[Address, ChecksumAddress, List[Union[Address, ChecksumAddress]]],
-    topics: List[Optional[Union[_Hash32, List[_Hash32]]]],
+    address: Address | ChecksumAddress | list[Address | ChecksumAddress],
+    topics: list[_Hash32 | list[_Hash32] | None],
     max_blocks: int,
-) -> AsyncIterable[List[LogReceipt]]:
+) -> AsyncIterable[list[LogReceipt]]:
     """
     Used to break up requests to ``eth_getLogs``
 
@@ -460,12 +455,12 @@ class AsyncRequestLogs:
     def __init__(
         self,
         w3: "AsyncWeb3[Any]",
-        from_block: Optional[Union[BlockNumber, LatestBlockParam]] = None,
-        to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None,
-        address: Optional[
-            Union[Address, ChecksumAddress, List[Union[Address, ChecksumAddress]]]
-        ] = None,
-        topics: Optional[List[Optional[Union[_Hash32, List[_Hash32]]]]] = None,
+        from_block: BlockNumber | LatestBlockParam | None = None,
+        to_block: BlockNumber | LatestBlockParam | None = None,
+        address: (
+            Address | ChecksumAddress | list[Address | ChecksumAddress] | None
+        ) = None,
+        topics: list[_Hash32 | list[_Hash32] | None] | None = None,
     ) -> None:
         self.address = address
         self.topics = topics
@@ -505,7 +500,7 @@ class AsyncRequestLogs:
 
         return to_block
 
-    async def _get_filter_changes(self) -> AsyncIterator[List[LogReceipt]]:
+    async def _get_filter_changes(self) -> AsyncIterator[list[LogReceipt]]:
         self_from_block = await self.from_block
         self_to_block = await self.to_block
         async for start, stop in async_iter_latest_block_ranges(
@@ -527,7 +522,7 @@ class AsyncRequestLogs:
                     for item in sublist
                 ]
 
-    async def get_logs(self) -> List[LogReceipt]:
+    async def get_logs(self) -> list[LogReceipt]:
         self_from_block = await self.from_block
         self_to_block = await self.to_block
         return [
@@ -557,10 +552,10 @@ class AsyncRequestBlocks:
         return closure().__await__()
 
     @property
-    def filter_changes(self) -> AsyncIterator[List[Hash32]]:
+    def filter_changes(self) -> AsyncIterator[list[Hash32]]:
         return self.get_filter_changes()
 
-    async def get_filter_changes(self) -> AsyncIterator[List[Hash32]]:
+    async def get_filter_changes(self) -> AsyncIterator[list[Hash32]]:
         block_range_iter = async_iter_latest_block_ranges(
             self.w3, self.start_block, None
         )
@@ -570,8 +565,8 @@ class AsyncRequestBlocks:
 
 
 async def async_block_hashes_in_range(
-    w3: "AsyncWeb3[Any]", block_range: Tuple[BlockNumber, BlockNumber]
-) -> List[Union[None, Hash32]]:
+    w3: "AsyncWeb3[Any]", block_range: tuple[BlockNumber, BlockNumber]
+) -> list[None | Hash32]:
     from_block, to_block = block_range
     if from_block is None or to_block is None:
         return []
@@ -596,8 +591,8 @@ def _simulate_rpc_response_with_result(filter_id: str) -> "RPCResponse":
 
 class LocalFilterMiddleware(Web3Middleware):
     def __init__(self, w3: Union["Web3", "AsyncWeb3[Any]"]):
-        self.filters: Dict[str, SyncFilter] = {}
-        self.async_filters: Dict[str, AsyncFilter] = {}
+        self.filters: dict[str, SyncFilter] = {}
+        self.async_filters: dict[str, AsyncFilter] = {}
         self.filter_id_counter = itertools.count()
         super().__init__(w3)
 

web3/middleware/formatting.py

@@ -4,7 +4,6 @@ from typing import (
     Callable,
     Coroutine,
     Literal,
-    Optional,
     Union,
     cast,
 )
@@ -116,12 +115,12 @@ class FormattingMiddlewareBuilder(Web3MiddlewareBuilder):
     def build(
         w3: Union["Web3", "AsyncWeb3[Any]"],
         # formatters option:
-        request_formatters: Optional[Formatters] = None,
-        result_formatters: Optional[Formatters] = None,
-        error_formatters: Optional[Formatters] = None,
+        request_formatters: Formatters | None = None,
+        result_formatters: Formatters | None = None,
+        error_formatters: Formatters | None = None,
         # formatters builder option:
-        sync_formatters_builder: Optional[SYNC_FORMATTERS_BUILDER] = None,
-        async_formatters_builder: Optional[ASYNC_FORMATTERS_BUILDER] = None,
+        sync_formatters_builder: SYNC_FORMATTERS_BUILDER | None = None,
+        async_formatters_builder: ASYNC_FORMATTERS_BUILDER | None = None,
     ) -> "FormattingMiddlewareBuilder":
         # if not both sync and async formatters are specified, raise error
         if (

web3/middleware/names.py

@@ -1,9 +1,7 @@
 from typing import (
     TYPE_CHECKING,
     Any,
-    Dict,
     Sequence,
-    Union,
     cast,
 )
 
@@ -71,7 +69,7 @@ async def async_format_all_ens_names_to_address(
 async def async_apply_ens_to_address_conversion(
     async_web3: "AsyncWeb3[Any]",
     params: Any,
-    abi_types_for_method: Union[Sequence[str], Dict[str, str]],
+    abi_types_for_method: Sequence[str] | dict[str, str],
 ) -> Any:
     if isinstance(abi_types_for_method, Sequence):
         formatted_params = await async_format_all_ens_names_to_address(

web3/middleware/signing.py

@@ -7,7 +7,6 @@ from typing import (
     Any,
     Collection,
     Iterable,
-    Tuple,
     TypeVar,
     Union,
     cast,
@@ -93,8 +92,8 @@ _PrivateKey = Union[LocalAccount, PrivateKey, HexStr, bytes]
 
 @to_dict
 def gen_normalized_accounts(
-    val: Union[_PrivateKey, Collection[_PrivateKey]],
-) -> Iterable[Tuple[ChecksumAddress, LocalAccount]]:
+    val: _PrivateKey | Collection[_PrivateKey],
+) -> Iterable[tuple[ChecksumAddress, LocalAccount]]:
     if isinstance(
         val,
         (
@@ -157,7 +156,7 @@ class SignAndSendRawMiddlewareBuilder(Web3MiddlewareBuilder):
     @staticmethod
     @curry
     def build(
-        private_key_or_account: Union[_PrivateKey, Collection[_PrivateKey]],
+        private_key_or_account: _PrivateKey | Collection[_PrivateKey],
         w3: Union["Web3", "AsyncWeb3[Any]"],
     ) -> "SignAndSendRawMiddlewareBuilder":
         middleware = SignAndSendRawMiddlewareBuilder(w3)

web3/middleware/stalecheck.py

@@ -2,7 +2,6 @@ import time
 from typing import (  # noqa: F401
     TYPE_CHECKING,
     Any,
-    Callable,
     Collection,
     Dict,
     Optional,
@@ -45,7 +44,7 @@ def _is_fresh(block: BlockData, allowable_delay: int) -> bool:
 class StalecheckMiddlewareBuilder(Web3MiddlewareBuilder):
     allowable_delay: int
     skip_stalecheck_for_methods: Collection[str]
-    cache: Dict[str, Optional[BlockData]]
+    cache: dict[str, BlockData | None]
 
     @staticmethod
     @curry

web3/middleware/validation.py

@@ -2,7 +2,6 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
-    Dict,
 )
 
 from eth_utils.curried import (
@@ -121,7 +120,7 @@ def _chain_id_validator(web3_chain_id: int) -> Callable[..., Any]:
 
 
 def _build_formatters_dict(
-    request_formatters: Dict[RPCEndpoint, Any],
+    request_formatters: dict[RPCEndpoint, Any],
 ) -> FormattersDict:
     return dict(
         request_formatters=request_formatters,

web3/module.py

@@ -3,10 +3,7 @@ from typing import (
     Any,
     Callable,
     Coroutine,
-    Dict,
-    Optional,
     Sequence,
-    Tuple,
     TypeVar,
     Union,
     cast,
@@ -63,13 +60,13 @@ def retrieve_request_information_for_batching(
     w3: Union["AsyncWeb3[Any]", "Web3"],
     module: "Module",
     method: Method[Callable[..., Any]],
-) -> Union[
-    Callable[..., Tuple[Tuple[RPCEndpoint, Any], Sequence[Any]]],
-    Callable[..., Coroutine[Any, Any, Tuple[Tuple[RPCEndpoint, Any], Sequence[Any]]]],
-]:
+) -> (
+    Callable[..., tuple[tuple[RPCEndpoint, Any], Sequence[Any]]]
+    | Callable[..., Coroutine[Any, Any, tuple[tuple[RPCEndpoint, Any], Sequence[Any]]]]
+):
     async def async_inner(
         *args: Any, **kwargs: Any
-    ) -> Tuple[Tuple[RPCEndpoint, Any], Sequence[Any]]:
+    ) -> tuple[tuple[RPCEndpoint, Any], Sequence[Any]]:
         (method_str, params), response_formatters = method.process_params(
             module, *args, **kwargs
         )
@@ -81,7 +78,7 @@ def retrieve_request_information_for_batching(
 
     def inner(
         *args: Any, **kwargs: Any
-    ) -> Tuple[Tuple[RPCEndpoint, Any], Sequence[Any]]:
+    ) -> tuple[tuple[RPCEndpoint, Any], Sequence[Any]]:
         (method_str, params), response_formatters = method.process_params(
             module, *args, **kwargs
         )
@@ -95,8 +92,8 @@ def retrieve_blocking_method_call_fn(
     w3: "Web3",
     module: "Module",
     method: Method[Callable[..., TReturn]],
-) -> Callable[..., Union[TReturn, LogFilter]]:
-    def caller(*args: Any, **kwargs: Any) -> Union[TReturn, LogFilter]:
+) -> Callable[..., TReturn | LogFilter]:
+    def caller(*args: Any, **kwargs: Any) -> TReturn | LogFilter:
         try:
             (method_str, params), response_formatters = method.process_params(
                 module, *args, **kwargs
@@ -127,12 +124,12 @@ def retrieve_async_method_call_fn(
     Coroutine[
         Any,
         Any,
-        Optional[Union[RPCResponse, FormattedEthSubscriptionResponse, AsyncLogFilter]],
+        RPCResponse | FormattedEthSubscriptionResponse | AsyncLogFilter | None,
     ],
 ]:
     async def caller(
         *args: Any, **kwargs: Any
-    ) -> Union[RPCResponse, FormattedEthSubscriptionResponse, AsyncLogFilter]:
+    ) -> RPCResponse | FormattedEthSubscriptionResponse | AsyncLogFilter:
         try:
             (method_str, params), response_formatters = method.process_params(
                 module, *args, **kwargs
@@ -184,7 +181,7 @@ class Module:
 
     def attach_methods(
         self,
-        methods: Dict[str, Method[Callable[..., Any]]],
+        methods: dict[str, Method[Callable[..., Any]]],
     ) -> None:
         for method_name, method_class in methods.items():
             klass = (

web3/providers/__init__.py

@@ -18,9 +18,6 @@ from .ipc import (
 from .rpc import (
     HTTPProvider,
 )
-from .legacy_websocket import (
-    LegacyWebSocketProvider,
-)
 from .persistent import (
     AsyncIPCProvider,
     PersistentConnection,
@@ -42,7 +39,6 @@ __all__ = [
     "HTTPProvider",
     "IPCProvider",
     "JSONBaseProvider",
-    "LegacyWebSocketProvider",
     "PersistentConnection",
     "PersistentConnectionProvider",
     "WebSocketProvider",

web3/providers/async_base.py

@@ -7,12 +7,7 @@ from typing import (
     Any,
     Callable,
     Coroutine,
-    Dict,
-    List,
     Optional,
-    Set,
-    Tuple,
-    Union,
     cast,
 )
 
@@ -54,8 +49,8 @@ from web3.utils import (
 )
 
 if TYPE_CHECKING:
-    from websockets.legacy.client import (
-        WebSocketClientProtocol,
+    from websockets.asyncio.client import (
+        ClientConnection,
     )
 
     from web3 import (  # noqa: F401
@@ -75,8 +70,8 @@ class AsyncBaseProvider:
     logger: logging.Logger = logging.getLogger(
         "web3.providers.async_base.AsyncBaseProvider"
     )
-    _request_func_cache: Tuple[
-        Tuple[Middleware, ...], Callable[..., Coroutine[Any, Any, RPCResponse]]
+    _request_func_cache: tuple[
+        tuple[Middleware, ...], Callable[..., Coroutine[Any, Any, RPCResponse]]
     ] = (None, None)
 
     is_async = True
@@ -87,10 +82,9 @@ class AsyncBaseProvider:
     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: asyncio.Lock = asyncio.Lock()
@@ -102,9 +96,9 @@ class AsyncBaseProvider:
         self._batching_context: contextvars.ContextVar[
             Optional["RequestBatcher[Any]"]
         ] = contextvars.ContextVar("batching_context", default=None)
-        self._batch_request_func_cache: Tuple[
-            Tuple[Middleware, ...],
-            Callable[..., Coroutine[Any, Any, Union[List[RPCResponse], RPCResponse]]],
+        self._batch_request_func_cache: tuple[
+            tuple[Middleware, ...],
+            Callable[..., Coroutine[Any, Any, list[RPCResponse] | RPCResponse]],
         ] = (None, None)
 
     @property
@@ -114,7 +108,7 @@ class AsyncBaseProvider:
     async def request_func(
         self, async_w3: "AsyncWeb3[Any]", middleware_onion: MiddlewareOnion
     ) -> Callable[..., Coroutine[Any, Any, RPCResponse]]:
-        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:
@@ -130,8 +124,8 @@ class AsyncBaseProvider:
 
     async def batch_request_func(
         self, async_w3: "AsyncWeb3[Any]", middleware_onion: MiddlewareOnion
-    ) -> Callable[..., Coroutine[Any, Any, Union[List[RPCResponse], RPCResponse]]]:
-        middleware: Tuple[Middleware, ...] = middleware_onion.as_tuple_of_middleware()
+    ) -> Callable[..., Coroutine[Any, Any, list[RPCResponse] | RPCResponse]]:
+        middleware: tuple[Middleware, ...] = middleware_onion.as_tuple_of_middleware()
 
         cache_key = self._batch_request_func_cache[0]
         if cache_key != middleware:
@@ -151,8 +145,8 @@ class AsyncBaseProvider:
         raise NotImplementedError("Providers must implement this method")
 
     async 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")
 
     async def is_connected(self, show_traceback: bool = False) -> bool:
@@ -175,11 +169,11 @@ class AsyncBaseProvider:
         )
 
     # WebSocket typing
-    _ws: "WebSocketClientProtocol"
+    _ws: "ClientConnection"
 
     # IPC typing
-    _reader: Optional[asyncio.StreamReader]
-    _writer: Optional[asyncio.StreamWriter]
+    _reader: asyncio.StreamReader | None
+    _writer: asyncio.StreamWriter | None
 
 
 class AsyncJSONBaseProvider(AsyncBaseProvider):
@@ -200,7 +194,7 @@ class AsyncJSONBaseProvider(AsyncBaseProvider):
     @staticmethod
     def encode_rpc_dict(rpc_dict: RPCRequest) -> bytes:
         encoded = FriendlyJsonSerde().json_encode(
-            cast(Dict[str, Any], rpc_dict), cls=Web3JsonEncoder
+            cast(dict[str, Any], rpc_dict), cls=Web3JsonEncoder
         )
         return to_bytes(text=encoded)
 
@@ -242,7 +236,7 @@ class AsyncJSONBaseProvider(AsyncBaseProvider):
     # -- batch requests -- #
 
     def encode_batch_rpc_request(
-        self, requests: List[Tuple[RPCEndpoint, Any]]
+        self, requests: list[tuple[RPCEndpoint, Any]]
     ) -> bytes:
         return (
             b"["
@@ -252,5 +246,5 @@ class AsyncJSONBaseProvider(AsyncBaseProvider):
             + b"]"
         )
 
-    def encode_batch_request_dicts(self, request_dicts: List[RPCRequest]) -> bytes:
+    def encode_batch_request_dicts(self, request_dicts: list[RPCRequest]) -> bytes:
         return b"[" + b",".join(self.encode_rpc_dict(d) for d in request_dicts) + b"]"

web3/providers/auto.py

@@ -2,13 +2,7 @@ import os
 from typing import (
     Any,
     Callable,
-    Dict,
-    List,
-    Optional,
     Sequence,
-    Tuple,
-    Type,
-    Union,
 )
 from urllib.parse import (
     urlparse,
@@ -25,7 +19,6 @@ from web3.providers import (
     HTTPProvider,
     IPCProvider,
     JSONBaseProvider,
-    LegacyWebSocketProvider,
 )
 from web3.types import (
     RPCEndpoint,
@@ -36,7 +29,7 @@ HTTP_SCHEMES = {"http", "https"}
 WS_SCHEMES = {"ws", "wss"}
 
 
-def load_provider_from_environment() -> Optional[JSONBaseProvider]:
+def load_provider_from_environment() -> JSONBaseProvider | None:
     uri_string = URI(os.environ.get("WEB3_PROVIDER_URI", ""))
     if not uri_string:
         return None
@@ -45,15 +38,13 @@ def load_provider_from_environment() -> Optional[JSONBaseProvider]:
 
 
 def load_provider_from_uri(
-    uri_string: URI, headers: Optional[Dict[str, Tuple[str, str]]] = None
+    uri_string: URI, headers: dict[str, tuple[str, str]] | None = None
 ) -> JSONBaseProvider:
     uri = urlparse(uri_string)
     if uri.scheme == "file":
         return IPCProvider(uri.path)
     elif uri.scheme in HTTP_SCHEMES:
         return HTTPProvider(uri_string, headers)
-    elif uri.scheme in WS_SCHEMES:
-        return LegacyWebSocketProvider(uri_string)
     else:
         raise NotImplementedError(
             "Web3 does not know how to connect to scheme "
@@ -66,15 +57,13 @@ class AutoProvider(JSONBaseProvider):
         load_provider_from_environment,
         IPCProvider,
         HTTPProvider,
-        LegacyWebSocketProvider,
     )
     _active_provider = None
 
     def __init__(
         self,
-        potential_providers: Optional[
-            Sequence[Union[Callable[..., JSONBaseProvider], Type[JSONBaseProvider]]]
-        ] = None,
+        potential_providers: None
+        | (Sequence[Callable[..., JSONBaseProvider] | type[JSONBaseProvider]]) = None,
     ) -> None:
         """
         :param iterable potential_providers: ordered series of provider classes
@@ -97,8 +86,8 @@ class AutoProvider(JSONBaseProvider):
             return self._proxy_request(method, params, use_cache=False)
 
     def make_batch_request(
-        self, requests: List[Tuple[RPCEndpoint, Any]]
-    ) -> Union[List[RPCResponse], RPCResponse]:
+        self, requests: list[tuple[RPCEndpoint, Any]]
+    ) -> list[RPCResponse] | RPCResponse:
         try:
             return self._proxy_batch_request(requests)
         except OSError:
@@ -121,8 +110,8 @@ class AutoProvider(JSONBaseProvider):
         return provider.make_request(method, params)
 
     def _proxy_batch_request(
-        self, requests: List[Tuple[RPCEndpoint, Any]], use_cache: bool = True
-    ) -> Union[List[RPCResponse], RPCResponse]:
+        self, requests: list[tuple[RPCEndpoint, Any]], use_cache: bool = True
+    ) -> list[RPCResponse] | RPCResponse:
         provider = self._get_active_provider(use_cache)
         if provider is None:
             raise CannotHandleRequest(
@@ -132,7 +121,7 @@ class AutoProvider(JSONBaseProvider):
 
         return provider.make_batch_request(requests)
 
-    def _get_active_provider(self, use_cache: bool) -> Optional[JSONBaseProvider]:
+    def _get_active_provider(self, use_cache: bool) -> JSONBaseProvider | None:
         if use_cache and self._active_provider is not None:
             return self._active_provider