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

web3/_utils/contracts.py

@@ -4,11 +4,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
-    Dict,
-    List,
-    Optional,
     Sequence,
-    Tuple,
     Union,
     cast,
 )
@@ -97,10 +93,10 @@ if TYPE_CHECKING:
 
 def find_matching_event_abi(
     abi: ABI,
-    event_name: Optional[str] = None,
-    argument_names: Optional[Sequence[str]] = None,
+    event_name: str | None = None,
+    argument_names: Sequence[str] | None = None,
 ) -> ABIEvent:
-    filters: List[functools.partial[Sequence[ABIElement]]] = [
+    filters: list[functools.partial[Sequence[ABIElement]]] = [
         functools.partial(filter_abi_by_type, "event"),
     ]
 
@@ -124,7 +120,7 @@ def encode_abi(
     w3: Union["AsyncWeb3[Any]", "Web3"],
     abi: ABIElement,
     arguments: Sequence[Any],
-    data: Optional[HexStr] = None,
+    data: HexStr | None = None,
 ) -> HexStr:
     argument_types = []
     try:
@@ -170,11 +166,11 @@ def prepare_transaction(
     address: ChecksumAddress,
     w3: Union["AsyncWeb3[Any]", "Web3"],
     abi_element_identifier: ABIElementIdentifier,
-    contract_abi: Optional[ABI] = None,
-    abi_callable: Optional[ABICallable] = None,
-    transaction: Optional[TxParams] = None,
-    fn_args: Optional[Sequence[Any]] = None,
-    fn_kwargs: Optional[Any] = None,
+    contract_abi: ABI | None = None,
+    abi_callable: ABICallable | None = None,
+    transaction: TxParams | None = None,
+    fn_args: Sequence[Any] | None = None,
+    fn_kwargs: Any | None = None,
 ) -> TxParams:
     """
     Returns a dictionary of the transaction that could be used to call this
@@ -234,10 +230,10 @@ def prepare_transaction(
 def encode_transaction_data(
     w3: Union["AsyncWeb3[Any]", "Web3"],
     abi_element_identifier: ABIElementIdentifier,
-    contract_abi: Optional[ABI] = None,
-    abi_callable: Optional[ABICallable] = None,
-    args: Optional[Sequence[Any]] = None,
-    kwargs: Optional[Any] = None,
+    contract_abi: ABI | None = None,
+    abi_callable: ABICallable | None = None,
+    args: Sequence[Any] | None = None,
+    kwargs: Any | None = None,
 ) -> HexStr:
     info_abi: ABIElement
     abi_element_name = get_name_from_abi_element_identifier(abi_element_identifier)
@@ -269,8 +265,8 @@ def encode_transaction_data(
 def decode_transaction_data(
     fn_abi: ABIFunction,
     data: HexStr,
-    normalizers: Sequence[Callable[[TypeStr, Any], Tuple[TypeStr, Any]]] = None,
-) -> Dict[str, Any]:
+    normalizers: Sequence[Callable[[TypeStr, Any], tuple[TypeStr, Any]]] = None,
+) -> dict[str, Any]:
     data_bytes = HexBytes(data)
     types = get_abi_input_types(fn_abi)
     abi_codec = ABICodec(default_registry)
@@ -281,34 +277,34 @@ def decode_transaction_data(
 
 
 def get_constructor_function_info(
-    contract_abi: Optional[ABI] = None, constructor_abi: Optional[ABIConstructor] = None
-) -> Tuple[ABIConstructor, HexStr, Tuple[Any, ...]]:
+    contract_abi: ABI | None = None, constructor_abi: ABIConstructor | None = None
+) -> tuple[ABIConstructor, HexStr, tuple[Any, ...]]:
     if constructor_abi is None:
         constructor_abi = cast(
             ABIConstructor, get_abi_element(contract_abi, "constructor")
         )
     fn_selector = encode_hex(b"")
-    fn_arguments: Tuple[Any, ...] = tuple()
+    fn_arguments: tuple[Any, ...] = tuple()
     return constructor_abi, fn_selector, fn_arguments
 
 
 def get_fallback_function_info(
-    contract_abi: Optional[ABI] = None, fallback_abi: Optional[ABIFallback] = None
-) -> Tuple[ABIFallback, HexStr, Tuple[Any, ...]]:
+    contract_abi: ABI | None = None, fallback_abi: ABIFallback | None = None
+) -> tuple[ABIFallback, HexStr, tuple[Any, ...]]:
     if fallback_abi is None:
         fallback_abi = cast(ABIFallback, get_abi_element(contract_abi, "fallback"))
     fn_selector = encode_hex(b"")
-    fn_arguments: Tuple[Any, ...] = tuple()
+    fn_arguments: tuple[Any, ...] = tuple()
     return fallback_abi, fn_selector, fn_arguments
 
 
 def get_receive_function_info(
-    contract_abi: Optional[ABI] = None, receive_abi: Optional[ABIReceive] = None
-) -> Tuple[ABIReceive, HexStr, Tuple[Any, ...]]:
+    contract_abi: ABI | None = None, receive_abi: ABIReceive | None = None
+) -> tuple[ABIReceive, HexStr, tuple[Any, ...]]:
     if receive_abi is None:
         receive_abi = cast(ABIReceive, get_abi_element(contract_abi, "receive"))
     fn_selector = encode_hex(b"")
-    fn_arguments: Tuple[Any, ...] = tuple()
+    fn_arguments: tuple[Any, ...] = tuple()
     return receive_abi, fn_selector, fn_arguments
 
 
@@ -335,7 +331,7 @@ def validate_payable(transaction: TxParams, abi_callable: ABICallable) -> None:
 
 
 def parse_block_identifier(
-    w3: "Web3", block_identifier: Optional[BlockIdentifier]
+    w3: "Web3", block_identifier: BlockIdentifier | None
 ) -> BlockIdentifier:
     if block_identifier is None:
         return w3.eth.default_block

web3/_utils/datatypes.py

@@ -1,10 +1,6 @@
 from typing import (
     Any,
     Collection,
-    Dict,
-    Optional,
-    Tuple,
-    Type,
 )
 
 from eth_utils import (
@@ -32,9 +28,9 @@ class PropertyCheckingFactory(type):
     def __init__(
         cls,
         name: str,
-        bases: Tuple[Type[Any], ...],
-        namespace: Dict[str, Any],
-        **kwargs: Dict[str, Any],
+        bases: tuple[type[Any], ...],
+        namespace: dict[str, Any],
+        **kwargs: dict[str, Any],
     ) -> None:
         # see PEP487.  To accept kwargs in __new__, they need to be
         # filtered out here.
@@ -44,9 +40,9 @@ class PropertyCheckingFactory(type):
     def __new__(
         mcs,
         name: str,
-        bases: Tuple[type],
-        namespace: Dict[str, Any],
-        normalizers: Optional[Dict[str, Any]] = None,
+        bases: tuple[type],
+        namespace: dict[str, Any],
+        normalizers: dict[str, Any] | None = None,
     ) -> "PropertyCheckingFactory":
         all_bases = set(concat(base.__mro__ for base in bases))
         all_keys = set(concat(base.__dict__.keys() for base in all_bases))

web3/_utils/decorators.py

@@ -3,8 +3,6 @@ import threading
 from typing import (
     Any,
     Callable,
-    Set,
-    Tuple,
     TypeVar,
     cast,
 )
@@ -22,7 +20,7 @@ def reject_recursive_repeats(to_wrap: Callable[..., Any]) -> Callable[..., Any]:
     Prevent simple cycles by returning None when called recursively with same instance
     """
     # types ignored b/c dynamically set attribute
-    already_called: Set[Tuple[int, ...]] = set()
+    already_called: set[tuple[int, ...]] = set()
     to_wrap.__already_called = already_called  # type: ignore
 
     add_call = already_called.add

web3/_utils/encoding.py

@@ -4,12 +4,8 @@ import re
 from typing import (
     Any,
     Callable,
-    Dict,
     Iterable,
-    Optional,
     Sequence,
-    Type,
-    Union,
 )
 
 from eth_abi.encoding import (
@@ -65,7 +61,7 @@ from web3.exceptions import (
 
 
 def hex_encode_abi_type(
-    abi_type: TypeStr, value: Any, force_size: Optional[int] = None
+    abi_type: TypeStr, value: Any, force_size: int | None = None
 ) -> HexStr:
     """
     Encodes value into a hex string in format of abi_type
@@ -146,7 +142,7 @@ zpad_bytes = pad_bytes(b"\0")
 
 @curry
 def text_if_str(
-    to_type: Callable[..., str], text_or_primitive: Union[Primitives, HexStr, str]
+    to_type: Callable[..., str], text_or_primitive: Primitives | HexStr | str
 ) -> str:
     """
     Convert to a type, assuming that strings can be only unicode text (not a hexstr)
@@ -164,7 +160,7 @@ def text_if_str(
 
 @curry
 def hexstr_if_str(
-    to_type: Callable[..., HexStr], hexstr_or_primitive: Union[Primitives, HexStr, str]
+    to_type: Callable[..., HexStr], hexstr_or_primitive: Primitives | HexStr | str
 ) -> HexStr:
     """
     Convert to a type, assuming that strings can be only hexstr (not unicode text)
@@ -194,7 +190,7 @@ class FriendlyJsonSerde:
     helpful information in the raised error messages.
     """
 
-    def _json_mapping_errors(self, mapping: Dict[Any, Any]) -> Iterable[str]:
+    def _json_mapping_errors(self, mapping: dict[Any, Any]) -> Iterable[str]:
         for key, val in mapping.items():
             try:
                 self._friendly_json_encode(val)
@@ -209,7 +205,7 @@ class FriendlyJsonSerde:
                 yield f"{index}: because ({exc})"
 
     def _friendly_json_encode(
-        self, obj: Dict[Any, Any], cls: Optional[Type[json.JSONEncoder]] = None
+        self, obj: dict[Any, Any], cls: type[json.JSONEncoder] | None = None
     ) -> str:
         try:
             encoded = json.dumps(obj, cls=cls)
@@ -228,7 +224,7 @@ class FriendlyJsonSerde:
             else:
                 raise full_exception
 
-    def json_decode(self, json_str: str) -> Dict[Any, Any]:
+    def json_decode(self, json_str: str) -> dict[Any, Any]:
         try:
             decoded = json.loads(json_str)
             return decoded
@@ -239,7 +235,7 @@ class FriendlyJsonSerde:
             raise json.decoder.JSONDecodeError(err_msg, exc.doc, exc.pos)
 
     def json_encode(
-        self, obj: Dict[Any, Any], cls: Optional[Type[json.JSONEncoder]] = None
+        self, obj: dict[Any, Any], cls: type[json.JSONEncoder] | None = None
     ) -> str:
         try:
             return self._friendly_json_encode(obj, cls=cls)
@@ -247,7 +243,7 @@ class FriendlyJsonSerde:
             raise Web3TypeError(f"Could not encode to JSON: {exc}")
 
 
-def to_4byte_hex(hex_or_str_or_bytes: Union[HexStr, str, bytes, int]) -> HexStr:
+def to_4byte_hex(hex_or_str_or_bytes: HexStr | str | bytes | int) -> HexStr:
     size_of_4bytes = 4 * 8
     byte_str = hexstr_if_str(to_bytes, hex_or_str_or_bytes)
     if len(byte_str) > 4:
@@ -297,7 +293,7 @@ def encode_single_packed(_type: TypeStr, value: Any) -> bytes:
 
 
 class Web3JsonEncoder(json.JSONEncoder):
-    def default(self, obj: Any) -> Union[Dict[Any, Any], HexStr]:
+    def default(self, obj: Any) -> dict[Any, Any] | HexStr:
         if isinstance(obj, AttributeDict):
             return obj.__dict__
         elif isinstance(obj, (HexBytes, bytes)):
@@ -310,7 +306,7 @@ class Web3JsonEncoder(json.JSONEncoder):
         return json.JSONEncoder.default(self, obj)
 
 
-def to_json(obj: Dict[Any, Any]) -> str:
+def to_json(obj: dict[Any, Any]) -> str:
     """
     Convert a complex object (like a transaction object) to a JSON string
     """

web3/_utils/ens.py

@@ -4,7 +4,6 @@ from contextlib import (
 from typing import (
     TYPE_CHECKING,
     Any,
-    Dict,
     Iterator,
     Union,
     cast,
@@ -58,7 +57,7 @@ def validate_name_has_address(ens: ENS, name: str) -> ChecksumAddress:
 
 
 class StaticENS:
-    def __init__(self, name_addr_pairs: Dict[str, ChecksumAddress]) -> None:
+    def __init__(self, name_addr_pairs: dict[str, ChecksumAddress]) -> None:
         self.registry = dict(name_addr_pairs)
 
     def address(self, name: str) -> ChecksumAddress:
@@ -66,7 +65,7 @@ class StaticENS:
 
 
 class AsyncStaticENS:
-    def __init__(self, name_addr_pairs: Dict[str, ChecksumAddress]) -> None:
+    def __init__(self, name_addr_pairs: dict[str, ChecksumAddress]) -> None:
         self.registry = dict(name_addr_pairs)
 
     async def address(self, name: str) -> ChecksumAddress:
@@ -75,7 +74,7 @@ class AsyncStaticENS:
 
 @contextmanager
 def ens_addresses(
-    w3: Union["Web3", "AsyncWeb3[Any]"], name_addr_pairs: Dict[str, ChecksumAddress]
+    w3: Union["Web3", "AsyncWeb3[Any]"], name_addr_pairs: dict[str, ChecksumAddress]
 ) -> Iterator[None]:
     original_ens = w3.ens
     if w3.provider.is_async:
@@ -88,7 +87,7 @@ def ens_addresses(
 
 @contextmanager
 def contract_ens_addresses(
-    contract: "Contract", name_addr_pairs: Dict[str, ChecksumAddress]
+    contract: "Contract", name_addr_pairs: dict[str, ChecksumAddress]
 ) -> Iterator[None]:
     """
     Use this context manager to temporarily resolve name/address pairs

web3/_utils/events.py

@@ -10,13 +10,8 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Collection,
-    Dict,
     Iterable,
-    List,
-    Optional,
     Sequence,
-    Tuple,
-    Union,
     cast,
 )
 
@@ -105,7 +100,7 @@ if TYPE_CHECKING:
 
 
 def _log_entry_data_to_bytes(
-    log_entry_data: Union[Primitives, HexStr, str],
+    log_entry_data: Primitives | HexStr | str,
 ) -> bytes:
     return hexstr_if_str(to_bytes, log_entry_data)
 
@@ -113,8 +108,8 @@ def _log_entry_data_to_bytes(
 def construct_event_topic_set(
     event_abi: ABIEvent,
     abi_codec: ABICodec,
-    arguments: Optional[Union[List[Any], Tuple[Any], Dict[str, Any]]] = None,
-) -> List[HexStr]:
+    arguments: list[Any] | tuple[Any] | dict[str, Any] | None = None,
+) -> list[HexStr]:
     if arguments is None:
         arguments = {}
     elif isinstance(arguments, (list, tuple)):
@@ -156,8 +151,8 @@ def construct_event_topic_set(
 def construct_event_data_set(
     event_abi: ABIEvent,
     abi_codec: ABICodec,
-    arguments: Optional[Union[Sequence[Any], Dict[str, Any]]] = None,
-) -> List[List[Optional[HexStr]]]:
+    arguments: Sequence[Any] | dict[str, Any] | None = None,
+) -> list[list[HexStr | None]]:
     if arguments is None:
         arguments = {}
     if isinstance(arguments, (list, tuple)):
@@ -207,7 +202,7 @@ def is_dynamic_sized_type(type_str: TypeStr) -> bool:
 
 @to_tuple
 def get_event_abi_types_for_decoding(
-    event_inputs: Sequence[Union[ABIComponent, ABIComponentIndexed]],
+    event_inputs: Sequence[ABIComponent | ABIComponentIndexed],
 ) -> Iterable[TypeStr]:
     """
     Event logs use the `keccak(value)` for indexed inputs of type `bytes` or
@@ -310,7 +305,7 @@ def pop_singlets(seq: Sequence[Any]) -> Iterable[Any]:
 
 @curry
 def remove_trailing_from_seq(
-    seq: Sequence[Any], remove_value: Optional[Any] = None
+    seq: Sequence[Any], remove_value: Any | None = None
 ) -> Sequence[Any]:
     index = len(seq)
     while index > 0 and seq[index - 1] == remove_value:
@@ -344,7 +339,7 @@ class BaseEventFilterBuilder:
         self,
         event_abi: ABIEvent,
         abi_codec: ABICodec,
-        formatter: Optional[EventData] = None,
+        formatter: EventData | None = None,
     ) -> None:
         self.event_abi = event_abi
         self.abi_codec = abi_codec
@@ -398,26 +393,26 @@ class BaseEventFilterBuilder:
             )
 
     @property
-    def ordered_args(self) -> Tuple[Any, ...]:
+    def ordered_args(self) -> tuple[Any, ...]:
         return tuple(map(self.args.__getitem__, self._ordered_arg_names))
 
     @property
     @to_tuple
-    def indexed_args(self) -> Tuple[Any, ...]:
+    def indexed_args(self) -> tuple[Any, ...]:
         return tuple(filter(is_indexed, self.ordered_args))
 
     @property
     @to_tuple
-    def data_args(self) -> Tuple[Any, ...]:
+    def data_args(self) -> tuple[Any, ...]:
         return tuple(filter(is_not_indexed, self.ordered_args))
 
     @property
-    def topics(self) -> List[HexStr]:
+    def topics(self) -> list[HexStr]:
         arg_topics = tuple(arg.match_values for arg in self.indexed_args)
         return normalize_topic_list(cons(to_hex(self.event_topic), arg_topics))
 
     @property
-    def data_argument_values(self) -> Tuple[Any, ...]:
+    def data_argument_values(self) -> tuple[Any, ...]:
         if self.data_args is not None:
             return tuple(arg.match_values for arg in self.data_args)
         else:
@@ -471,7 +466,7 @@ class AsyncEventFilterBuilder(BaseEventFilterBuilder):
         return log_filter
 
 
-def initialize_event_topics(event_abi: ABIEvent) -> Union[bytes, List[Any]]:
+def initialize_event_topics(event_abi: ABIEvent) -> bytes | list[Any]:
     if event_abi["anonymous"] is False:
         return event_abi_to_log_topic(event_abi)
     else:
@@ -481,7 +476,7 @@ def initialize_event_topics(event_abi: ABIEvent) -> Union[bytes, List[Any]]:
 @to_dict
 def _build_argument_filters_from_event_abi(
     event_abi: ABIEvent, abi_codec: ABICodec
-) -> Iterable[Tuple[str, "BaseArgumentFilter"]]:
+) -> Iterable[tuple[str, "BaseArgumentFilter"]]:
     for item in event_abi["inputs"]:
         key = item["name"]
         value: "BaseArgumentFilter"
@@ -504,7 +499,7 @@ def _normalize_match_values(match_values: Collection[Any]) -> Iterable[Any]:
 
 
 class BaseArgumentFilter(ABC):
-    _match_values: Tuple[Any, ...] = None
+    _match_values: tuple[Any, ...] = None
     _immutable = False
 
     def __init__(self, arg_type: TypeStr) -> None:
@@ -539,7 +534,7 @@ class BaseArgumentFilter(ABC):
 class DataArgumentFilter(BaseArgumentFilter):
     # type ignore b/c conflict with BaseArgumentFilter.match_values type
     @property
-    def match_values(self) -> Tuple[TypeStr, Tuple[Any, ...]]:  # type: ignore
+    def match_values(self) -> tuple[TypeStr, tuple[Any, ...]]:  # type: ignore
         return self.arg_type, self._match_values
 
 
@@ -554,7 +549,7 @@ class TopicArgumentFilter(BaseArgumentFilter):
 
     # type ignore b/c conflict with BaseArgumentFilter.match_values type
     @property
-    def match_values(self) -> Optional[Tuple[HexStr, ...]]:  # type: ignore
+    def match_values(self) -> tuple[HexStr, ...] | None:  # type: ignore
         if self._match_values is not None:
             return self._get_match_values()
         else:
@@ -574,5 +569,5 @@ class EventLogErrorFlags(Enum):
     Warn = "warn"
 
     @classmethod
-    def flag_options(self) -> List[str]:
+    def flag_options(self) -> list[str]:
         return [key.upper() for key in self.__members__.keys()]

web3/_utils/filters.py

@@ -3,14 +3,8 @@ from typing import (
     Any,
     Callable,
     Collection,
-    Dict,
     Iterator,
-    List,
-    Optional,
     Sequence,
-    Set,
-    Tuple,
-    Union,
 )
 
 from eth_abi.codec import (
@@ -68,8 +62,8 @@ if TYPE_CHECKING:
 
 
 def _sanitize_addresses(
-    *address: Union[ChecksumAddress, List[ChecksumAddress]],
-) -> Union[ChecksumAddress, List[ChecksumAddress]]:
+    *address: ChecksumAddress | list[ChecksumAddress],
+) -> ChecksumAddress | list[ChecksumAddress]:
     """
     Validates an address or list of addresses and returns a single
     ChecksumAddress or a list of ChecksumAddresses.
@@ -78,7 +72,7 @@ def _sanitize_addresses(
     :param address: A single address or a list of addresses.
     :return: A list of ChecksumAddress.
     """
-    address_set: Set[ChecksumAddress] = set()
+    address_set: set[ChecksumAddress] = set()
     for arg in address:
         if not arg:
             continue
@@ -103,13 +97,13 @@ def _sanitize_addresses(
 def construct_event_filter_params(
     event_abi: ABIEvent,
     abi_codec: ABICodec,
-    contract_address: Optional[Union[ChecksumAddress, List[ChecksumAddress]]] = None,
-    argument_filters: Optional[Dict[str, Any]] = None,
-    topics: Optional[Sequence[HexStr]] = None,
-    from_block: Optional[BlockIdentifier] = None,
-    to_block: Optional[BlockIdentifier] = None,
-    address: Optional[Union[ChecksumAddress, List[ChecksumAddress]]] = None,
-) -> Tuple[List[List[Optional[HexStr]]], FilterParams]:
+    contract_address: ChecksumAddress | list[ChecksumAddress] | None = None,
+    argument_filters: dict[str, Any] | None = None,
+    topics: Sequence[HexStr] | None = None,
+    from_block: BlockIdentifier | None = None,
+    to_block: BlockIdentifier | None = None,
+    address: ChecksumAddress | list[ChecksumAddress] | None = None,
+) -> tuple[list[list[HexStr | None]], FilterParams]:
     filter_params: FilterParams = {}
     topic_set: Sequence[HexStr] = construct_event_topic_set(
         event_abi, abi_codec, argument_filters
@@ -141,7 +135,7 @@ def construct_event_filter_params(
 
 
 class BaseFilter:
-    callbacks: List[Callable[..., Any]] = None
+    callbacks: list[Callable[..., Any]] = None
     stopped = False
     poll_interval = None
     filter_id = None
@@ -173,8 +167,8 @@ class BaseFilter:
         return filter(self.is_valid_entry, entries)
 
     def _format_log_entries(
-        self, log_entries: Optional[Iterator[LogReceipt]] = None
-    ) -> List[LogReceipt]:
+        self, log_entries: Iterator[LogReceipt] | None = None
+    ) -> list[LogReceipt]:
         if log_entries is None:
             return []
 
@@ -189,13 +183,13 @@ class Filter(BaseFilter):
         self.eth_module = eth_module
         super().__init__(filter_id)
 
-    def get_new_entries(self) -> List[LogReceipt]:
+    def get_new_entries(self) -> list[LogReceipt]:
         log_entries = self._filter_valid_entries(
             self.eth_module.get_filter_changes(self.filter_id)
         )
         return self._format_log_entries(log_entries)
 
-    def get_all_entries(self) -> List[LogReceipt]:
+    def get_all_entries(self) -> list[LogReceipt]:
         log_entries = self._filter_valid_entries(
             self.eth_module.get_filter_logs(self.filter_id)
         )
@@ -207,12 +201,12 @@ class AsyncFilter(BaseFilter):
         self.eth_module = eth_module
         super().__init__(filter_id)
 
-    async def get_new_entries(self) -> List[LogReceipt]:
+    async def get_new_entries(self) -> list[LogReceipt]:
         filter_changes = await self.eth_module.get_filter_changes(self.filter_id)
         log_entries = self._filter_valid_entries(filter_changes)
         return self._format_log_entries(log_entries)
 
-    async def get_all_entries(self) -> List[LogReceipt]:
+    async def get_all_entries(self) -> list[LogReceipt]:
         filter_logs = await self.eth_module.get_filter_logs(self.filter_id)
         log_entries = self._filter_valid_entries(filter_logs)
         return self._format_log_entries(log_entries)
@@ -257,7 +251,7 @@ class LogFilter(Filter):
         return entry
 
     def set_data_filters(
-        self, data_filter_set: Collection[Tuple[TypeStr, Any]]
+        self, data_filter_set: Collection[tuple[TypeStr, Any]]
     ) -> None:
         """
         Sets the data filters (non indexed argument filters)
@@ -300,7 +294,7 @@ class AsyncLogFilter(AsyncFilter):
         return entry
 
     def set_data_filters(
-        self, data_filter_set: Collection[Tuple[TypeStr, Any]]
+        self, data_filter_set: Collection[tuple[TypeStr, Any]]
     ) -> None:
         """
         Sets the data filters (non indexed argument filters)
@@ -346,7 +340,7 @@ def normalize_data_values(type_string: TypeStr, data_value: Any) -> Any:
 
 @curry
 def match_fn(
-    codec: ABICodec, match_values_and_abi: Collection[Tuple[str, Any]], data: Any
+    codec: ABICodec, match_values_and_abi: Collection[tuple[str, Any]], data: Any
 ) -> bool:
     """
     Match function used for filtering non-indexed event arguments.
@@ -382,17 +376,17 @@ class _UseExistingFilter(Exception):
     Internal exception, raised when a filter_id is passed into w3.eth.filter()
     """
 
-    def __init__(self, filter_id: Union[str, FilterParams, HexStr]) -> None:
+    def __init__(self, filter_id: str | FilterParams | HexStr) -> None:
         self.filter_id = filter_id
 
 
 @curry
 def select_filter_method(
-    value: Union[str, FilterParams, HexStr],
+    value: str | FilterParams | HexStr,
     if_new_block_filter: RPCEndpoint,
     if_new_pending_transaction_filter: RPCEndpoint,
     if_new_filter: RPCEndpoint,
-) -> Optional[RPCEndpoint]:
+) -> RPCEndpoint | None:
     if is_string(value):
         if value == "latest":
             return if_new_block_filter