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

web3/_utils/abi.py

@@ -12,15 +12,9 @@ from typing import (
     Callable,
     Collection,
     Coroutine,
-    Dict,
     Iterable,
-    List,
     Mapping,
-    Optional,
     Sequence,
-    Tuple,
-    Type,
-    Union,
     cast,
 )
 
@@ -114,21 +108,21 @@ def receive_func_abi_exists(contract_abi: ABI) -> Sequence[ABIReceive]:
     return filter_abi_by_type("receive", contract_abi)
 
 
-def get_indexed_event_inputs(event_abi: ABIEvent) -> List[ABIComponentIndexed]:
+def get_indexed_event_inputs(event_abi: ABIEvent) -> list[ABIComponentIndexed]:
     return [arg for arg in event_abi["inputs"] if arg["indexed"] is True]
 
 
-def exclude_indexed_event_inputs(event_abi: ABIEvent) -> List[ABIComponentIndexed]:
+def exclude_indexed_event_inputs(event_abi: ABIEvent) -> list[ABIComponentIndexed]:
     return [arg for arg in event_abi["inputs"] if arg["indexed"] is False]
 
 
-def filter_by_types(types: Collection[str], contract_abi: ABI) -> List[ABIElement]:
+def filter_by_types(types: Collection[str], contract_abi: ABI) -> list[ABIElement]:
     return [abi_element for abi_element in contract_abi if abi_element["type"] in types]
 
 
 def filter_by_argument_name(
     argument_names: Collection[str], contract_abi: ABI
-) -> List[ABIElement]:
+) -> list[ABIElement]:
     """
     Return a list of each ``ABIElement`` which contains arguments matching provided
     names.
@@ -150,7 +144,7 @@ def filter_by_argument_name(
 
 def filter_by_argument_type(
     argument_types: Collection[str], contract_abi: ABI
-) -> List[ABIElement]:
+) -> list[ABIElement]:
     """
     Return a list of each ``ABIElement`` which contains arguments matching provided
     types.
@@ -185,7 +179,7 @@ def get_name_from_abi_element_identifier(
 
 def get_abi_element_signature(
     abi_element_identifier: ABIElementIdentifier,
-    abi_element_argument_types: Optional[Iterable[str]] = None,
+    abi_element_argument_types: Iterable[str] | None = None,
 ) -> str:
     element_name = get_name_from_abi_element_identifier(abi_element_identifier)
     argument_types = ",".join(abi_element_argument_types or [])
@@ -206,7 +200,7 @@ class AddressEncoder(encoding.AddressEncoder):
 
 
 class AcceptsHexStrEncoder(encoding.BaseEncoder):
-    subencoder_cls: Type[encoding.BaseEncoder] = None
+    subencoder_cls: type[encoding.BaseEncoder] = None
     is_strict: bool = None
     is_big_endian: bool = False
     data_byte_size: int = None
@@ -215,7 +209,7 @@ class AcceptsHexStrEncoder(encoding.BaseEncoder):
     def __init__(
         self,
         subencoder: encoding.BaseEncoder,
-        **kwargs: Dict[str, Any],
+        **kwargs: dict[str, Any],
     ) -> None:
         super().__init__(**kwargs)  # type: ignore[no-untyped-call]
         self.subencoder = subencoder
@@ -234,7 +228,7 @@ class AcceptsHexStrEncoder(encoding.BaseEncoder):
         return cls(subencoder)
 
     @classmethod
-    def get_subencoder_class(cls) -> Type[encoding.BaseEncoder]:
+    def get_subencoder_class(cls) -> type[encoding.BaseEncoder]:
         if cls.subencoder_cls is None:
             raise Web3AttributeError(f"No subencoder class is set. {cls.__name__}")
         return cls.subencoder_cls
@@ -358,7 +352,7 @@ class TextStringEncoder(encoding.TextStringEncoder):
 TUPLE_TYPE_STR_RE = re.compile(r"^(tuple)((\[([1-9]\d*\b)?])*)??$")
 
 
-def get_tuple_type_str_parts(s: str) -> Optional[Tuple[str, Optional[str]]]:
+def get_tuple_type_str_parts(s: str) -> tuple[str, str | None] | None:
     """
     Takes a JSON ABI type string.  For tuple type strings, returns the separated
     prefix and array dimension parts.  For all other strings, returns ``None``.
@@ -375,8 +369,8 @@ def get_tuple_type_str_parts(s: str) -> Optional[Tuple[str, Optional[str]]]:
 
 
 def _align_abi_input(
-    arg_abi: Union[ABIComponent, ABIComponentIndexed], arg: Any
-) -> Tuple[Any, ...]:
+    arg_abi: ABIComponent | ABIComponentIndexed, arg: Any
+) -> tuple[Any, ...]:
     """
     Aligns the values of any mapping at any level of nesting in ``arg``
     according to the layout of the corresponding abi spec.
@@ -565,7 +559,7 @@ def is_probably_enum(abi_type: TypeStr) -> bool:
 @to_tuple
 def normalize_event_input_types(
     abi_args: Collection[ABIEvent],
-) -> Iterable[Union[ABIEvent, Dict[TypeStr, Any]]]:
+) -> Iterable[ABIEvent | dict[TypeStr, Any]]:
     for arg in abi_args:
         if is_recognized_type(arg["type"]):
             yield arg
@@ -584,7 +578,7 @@ def normalize_event_input_types(
 
 @curry
 def map_abi_data(
-    normalizers: Iterable[Callable[[TypeStr, Any], Tuple[TypeStr, Any]]],
+    normalizers: Iterable[Callable[[TypeStr, Any], tuple[TypeStr, Any]]],
     types: Iterable[TypeStr],
     data: Iterable[Any],
 ) -> Any:
@@ -624,7 +618,7 @@ def map_abi_data(
 @curry
 def abi_data_tree(
     types: Iterable[TypeStr], data: Iterable[Any]
-) -> List["ABITypedData"]:
+) -> list["ABITypedData"]:
     """
     Decorate the data tree with pairs of (type, data). The pair tuple is actually an
     ABITypedData, but can be accessed as a tuple.
@@ -639,7 +633,7 @@ def abi_data_tree(
 
 @curry
 def data_tree_map(
-    func: Callable[[TypeStr, Any], Tuple[TypeStr, Any]], data_tree: Any
+    func: Callable[[TypeStr, Any], tuple[TypeStr, Any]], data_tree: Any
 ) -> "ABITypedData":
     """
     Map func to every ABITypedData element in the tree. func will
@@ -679,7 +673,7 @@ class ABITypedData(namedtuple("ABITypedData", "abi_type, data")):
 
 
 def abi_sub_tree(
-    type_str_or_abi_type: Optional[Union[TypeStr, ABIType]], data_value: Any
+    type_str_or_abi_type: TypeStr | ABIType | None, data_value: Any
 ) -> ABITypedData:
     if type_str_or_abi_type is None:
         return ABITypedData([None, data_value])
@@ -801,12 +795,16 @@ def build_strict_registry() -> ABIRegistry:
 
 def named_tree(
     abi: Iterable[
-        Union[
-            ABIComponent, ABIComponentIndexed, ABIFunction, ABIEvent, Dict[TypeStr, Any]
-        ]
+        (
+            ABIComponent
+            | ABIComponentIndexed
+            | ABIFunction
+            | ABIEvent
+            | dict[TypeStr, Any]
+        )
     ],
-    data: Iterable[Tuple[Any, ...]],
-) -> Dict[str, Any]:
+    data: Iterable[tuple[Any, ...]],
+) -> dict[str, Any]:
     """
     Convert function inputs/outputs or event data tuple to dict with names from ABI.
     """
@@ -817,12 +815,12 @@ def named_tree(
 
 
 def _named_subtree(
-    abi: Union[
-        ABIComponent, ABIComponentIndexed, ABIFunction, ABIEvent, Dict[TypeStr, Any]
-    ],
-    data: Tuple[Any, ...],
-) -> Union[Dict[str, Any], Tuple[Any, ...], List[Any]]:
-    abi_type = parse(collapse_if_tuple(cast(Dict[str, Any], abi)))
+    abi: (
+        ABIComponent | ABIComponentIndexed | ABIFunction | ABIEvent | dict[TypeStr, Any]
+    ),
+    data: tuple[Any, ...],
+) -> dict[str, Any] | tuple[Any, ...] | list[Any]:
+    abi_type = parse(collapse_if_tuple(cast(dict[str, Any], abi)))
 
     if abi_type.is_array:
         item_type = abi_type.item_type.to_type_str()
@@ -850,10 +848,10 @@ def _named_subtree(
     return data
 
 
-def recursive_dict_to_namedtuple(data: Dict[str, Any]) -> Tuple[Any, ...]:
+def recursive_dict_to_namedtuple(data: dict[str, Any]) -> tuple[Any, ...]:
     def _dict_to_namedtuple(
-        value: Union[Dict[str, Any], List[Any]],
-    ) -> Union[Tuple[Any, ...], List[Any]]:
+        value: dict[str, Any] | list[Any],
+    ) -> tuple[Any, ...] | list[Any]:
         if not isinstance(value, dict):
             return value
 
@@ -864,8 +862,8 @@ def recursive_dict_to_namedtuple(data: Dict[str, Any]) -> Tuple[Any, ...]:
 
 
 def abi_decoded_namedtuple_factory(
-    fields: Tuple[Any, ...],
-) -> Callable[..., Tuple[Any, ...]]:
+    fields: tuple[Any, ...],
+) -> Callable[..., tuple[Any, ...]]:
     class ABIDecodedNamedTuple(namedtuple("ABIDecodedNamedTuple", fields, rename=True)):  # type: ignore # noqa: E501
         def __new__(self, args: Any) -> "ABIDecodedNamedTuple":
             return super().__new__(self, *args)
@@ -879,7 +877,7 @@ def abi_decoded_namedtuple_factory(
 async def async_data_tree_map(
     async_w3: "AsyncWeb3[Any]",
     func: Callable[
-        ["AsyncWeb3[Any]", TypeStr, Any], Coroutine[Any, Any, Tuple[TypeStr, Any]]
+        ["AsyncWeb3[Any]", TypeStr, Any], Coroutine[Any, Any, tuple[TypeStr, Any]]
     ],
     data_tree: Any,
 ) -> "ABITypedData":

web3/_utils/async_transactions.py

@@ -1,9 +1,6 @@
 from typing import (
     TYPE_CHECKING,
     Any,
-    Dict,
-    Optional,
-    Union,
     cast,
 )
 
@@ -47,13 +44,13 @@ if TYPE_CHECKING:
 
 # unused vars present in these funcs because they all need to have the same signature
 async def _estimate_gas(
-    async_w3: "AsyncWeb3[Any]", tx: TxParams, _defaults: Dict[str, Union[bytes, int]]
+    async_w3: "AsyncWeb3[Any]", tx: TxParams, _defaults: dict[str, bytes | int]
 ) -> int:
     return await async_w3.eth.estimate_gas(tx)
 
 
 async def _max_fee_per_gas(
-    async_w3: "AsyncWeb3[Any]", tx: TxParams, defaults: Dict[str, Union[bytes, int]]
+    async_w3: "AsyncWeb3[Any]", tx: TxParams, defaults: dict[str, bytes | int]
 ) -> Wei:
     block = await async_w3.eth.get_block("latest")
     max_priority_fee = tx.get(
@@ -63,13 +60,13 @@ async def _max_fee_per_gas(
 
 
 async def _max_priority_fee_gas(
-    async_w3: "AsyncWeb3[Any]", _tx: TxParams, _defaults: Dict[str, Union[bytes, int]]
+    async_w3: "AsyncWeb3[Any]", _tx: TxParams, _defaults: dict[str, bytes | int]
 ) -> Wei:
     return await async_w3.eth.max_priority_fee
 
 
 async def _chain_id(
-    async_w3: "AsyncWeb3[Any]", _tx: TxParams, _defaults: Dict[str, Union[bytes, int]]
+    async_w3: "AsyncWeb3[Any]", _tx: TxParams, _defaults: dict[str, bytes | int]
 ) -> int:
     return await async_w3.eth.chain_id
 
@@ -86,7 +83,7 @@ TRANSACTION_DEFAULTS = {
 
 
 async def get_block_gas_limit(
-    web3_eth: "AsyncEth", block_identifier: Optional[BlockIdentifier] = None
+    web3_eth: "AsyncEth", block_identifier: BlockIdentifier | None = None
 ) -> int:
     block = await web3_eth.get_block(block_identifier or "latest")
     return block["gasLimit"]
@@ -136,7 +133,7 @@ async def async_fill_transaction_defaults(
         or any_in_dict(DYNAMIC_FEE_TXN_PARAMS, transaction)
     )
 
-    defaults: Dict[str, Union[bytes, int]] = {}
+    defaults: dict[str, bytes | int] = {}
     for key, default_getter in TRANSACTION_DEFAULTS.items():
         if key not in transaction:
             if (

web3/_utils/batching.py

@@ -6,11 +6,7 @@ from typing import (
     Any,
     Callable,
     Coroutine,
-    Dict,
     Generic,
-    List,
-    Tuple,
-    Type,
     Union,
     cast,
 )
@@ -58,7 +54,7 @@ if TYPE_CHECKING:
 
 BATCH_REQUEST_ID = "batch_request"  # for use as the cache key for batch requests
 
-BatchRequestInformation = Tuple[Tuple["RPCEndpoint", Any], Tuple[Any, ...]]
+BatchRequestInformation = tuple[tuple["RPCEndpoint", Any], tuple[Any, ...]]
 RPC_METHODS_UNSUPPORTED_DURING_BATCH = {
     "eth_subscribe",
     "eth_unsubscribe",
@@ -73,8 +69,8 @@ RPC_METHODS_UNSUPPORTED_DURING_BATCH = {
 class RequestBatcher(Generic[TFunc]):
     def __init__(self, web3: Union["AsyncWeb3[Any]", "Web3"]) -> None:
         self.web3 = web3
-        self._requests_info: List[BatchRequestInformation] = []
-        self._async_requests_info: List[
+        self._requests_info: list[BatchRequestInformation] = []
+        self._async_requests_info: list[
             Coroutine[Any, Any, BatchRequestInformation]
         ] = []
         self._initialize_batching()
@@ -120,14 +116,14 @@ class RequestBatcher(Generic[TFunc]):
 
     def add_mapping(
         self,
-        batch_payload: Dict[
+        batch_payload: dict[
             Union[
                 "Method[Callable[..., Any]]",
                 Callable[..., Any],
                 "ContractFunction",
                 "AsyncContractFunction",
             ],
-            List[Any],
+            list[Any],
         ],
     ) -> None:
         self._validate_is_batching()
@@ -135,7 +131,7 @@ class RequestBatcher(Generic[TFunc]):
             for param in params:
                 self.add(method(param))
 
-    def execute(self) -> List["RPCResponse"]:
+    def execute(self) -> list["RPCResponse"]:
         self._validate_is_batching()
         responses = self.web3.manager._make_batch_request(self._requests_info)
         self._end_batching()
@@ -156,7 +152,7 @@ class RequestBatcher(Generic[TFunc]):
 
     def __exit__(
         self,
-        exc_type: Type[BaseException],
+        exc_type: type[BaseException],
         exc_val: BaseException,
         exc_tb: TracebackType,
     ) -> None:
@@ -164,7 +160,7 @@ class RequestBatcher(Generic[TFunc]):
 
     # -- async -- #
 
-    async def async_execute(self) -> List["RPCResponse"]:
+    async def async_execute(self) -> list["RPCResponse"]:
         self._validate_is_batching()
         if self._provider.has_persistent_connection:
             responses = await self.web3.manager._async_make_socket_batch_request(
@@ -185,7 +181,7 @@ class RequestBatcher(Generic[TFunc]):
 
     async def __aexit__(
         self,
-        exc_type: Type[BaseException],
+        exc_type: type[BaseException],
         exc_val: BaseException,
         exc_tb: TracebackType,
     ) -> None:
@@ -193,8 +189,8 @@ class RequestBatcher(Generic[TFunc]):
 
 
 def sort_batch_response_by_response_ids(
-    responses: List["RPCResponse"],
-) -> List["RPCResponse"]:
+    responses: list["RPCResponse"],
+) -> list["RPCResponse"]:
     if all(response.get("id") is not None for response in responses):
         # If all responses have an `id`, sort them by `id`, since the JSON-RPC 2.0 spec
         # doesn't guarantee order.

web3/_utils/blocks.py

@@ -1,6 +1,5 @@
 from typing import (
     Any,
-    Optional,
 )
 
 from eth_utils import (
@@ -62,7 +61,7 @@ def is_hex_encoded_block_number(value: Any) -> bool:
 @curry
 def select_method_for_block_identifier(
     value: Any, if_hash: RPCEndpoint, if_number: RPCEndpoint, if_predefined: RPCEndpoint
-) -> Optional[RPCEndpoint]:
+) -> RPCEndpoint | None:
     if is_predefined_block_number(value):
         return if_predefined
     elif isinstance(value, bytes):

web3/_utils/caching/caching_utils.py

@@ -1,18 +1,13 @@
-from asyncio import (
-    iscoroutinefunction,
-)
 import collections
 import hashlib
+import inspect
 import threading
 from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
     Coroutine,
-    Dict,
-    List,
     Sequence,
-    Tuple,
     Union,
 )
 
@@ -99,8 +94,8 @@ class RequestInformation:
         self,
         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],
         ],
@@ -110,13 +105,13 @@ class RequestInformation:
         self.params = params
         self.response_formatters = response_formatters
         self.subscription_id = subscription_id
-        self.middleware_response_processors: List[Callable[..., Any]] = []
+        self.middleware_response_processors: list[Callable[..., Any]] = []
 
 
 DEFAULT_VALIDATION_THRESHOLD = 60 * 60  # 1 hour
 
-CHAIN_VALIDATION_THRESHOLD_DEFAULTS: Dict[
-    int, Union[RequestCacheValidationThreshold, int]
+CHAIN_VALIDATION_THRESHOLD_DEFAULTS: dict[
+    int, RequestCacheValidationThreshold | int
 ] = {
     # Suggested safe values as defaults for each chain. Users can configure a different
     # value if desired.
@@ -136,7 +131,7 @@ CHAIN_VALIDATION_THRESHOLD_DEFAULTS: Dict[
 
 
 def is_cacheable_request(
-    provider: Union[ASYNC_PROVIDER_TYPE, SYNC_PROVIDER_TYPE],
+    provider: ASYNC_PROVIDER_TYPE | SYNC_PROVIDER_TYPE,
     method: RPCEndpoint,
     params: Any,
 ) -> bool:
@@ -176,10 +171,10 @@ BLOCKHASH_IN_PARAMS = {
     RPC.eth_getUncleCountByBlockHash,
 }
 
-INTERNAL_VALIDATION_MAP: Dict[
+INTERNAL_VALIDATION_MAP: dict[
     RPCEndpoint,
     Callable[
-        [SYNC_PROVIDER_TYPE, Sequence[Any], Dict[str, Any]],
+        [SYNC_PROVIDER_TYPE, Sequence[Any], dict[str, Any]],
         bool,
     ],
 ] = {
@@ -268,11 +263,11 @@ def handle_request_caching(
 # -- async -- #
 
 ASYNC_VALIDATOR_TYPE = Callable[
-    ["AsyncBaseProvider", Sequence[Any], Dict[str, Any]],
+    ["AsyncBaseProvider", Sequence[Any], dict[str, Any]],
     Union[bool, Coroutine[Any, Any, bool]],
 ]
 
-ASYNC_INTERNAL_VALIDATION_MAP: Dict[RPCEndpoint, ASYNC_VALIDATOR_TYPE] = {
+ASYNC_INTERNAL_VALIDATION_MAP: dict[RPCEndpoint, ASYNC_VALIDATOR_TYPE] = {
     **{endpoint: always_cache_request for endpoint in ALWAYS_CACHE},
     **{
         endpoint: async_validate_from_block_id_in_params
@@ -333,7 +328,7 @@ async def _async_should_cache_response(
         cache_validator = ASYNC_INTERNAL_VALIDATION_MAP[method]
         return (
             await cache_validator(provider, params, result)
-            if iscoroutinefunction(cache_validator)
+            if inspect.iscoroutinefunction(cache_validator)
             else cache_validator(provider, params, result)
         )
     return True

web3/_utils/caching/request_caching_validation.py

@@ -2,10 +2,8 @@ import time
 from typing import (
     TYPE_CHECKING,
     Any,
-    Dict,
     Sequence,
     TypeVar,
-    Union,
 )
 
 from web3.types import (
@@ -29,7 +27,7 @@ SYNC_PROVIDER_TYPE = TypeVar("SYNC_PROVIDER_TYPE", bound="BaseProvider")
 
 
 def _error_log(
-    provider: Union[ASYNC_PROVIDER_TYPE, SYNC_PROVIDER_TYPE], e: Exception
+    provider: ASYNC_PROVIDER_TYPE | SYNC_PROVIDER_TYPE, e: Exception
 ) -> None:
     provider.logger.error(
         "There was an exception while caching the request.", exc_info=e
@@ -87,7 +85,7 @@ def is_beyond_validation_threshold(
 def validate_from_block_id_in_params(
     provider: SYNC_PROVIDER_TYPE,
     params: Sequence[Any],
-    _result: Dict[str, Any],
+    _result: dict[str, Any],
 ) -> bool:
     block_id = params[0]
     if block_id == "earliest":
@@ -101,7 +99,7 @@ def validate_from_block_id_in_params(
 def validate_from_blocknum_in_result(
     provider: SYNC_PROVIDER_TYPE,
     _params: Sequence[Any],
-    result: Dict[str, Any],
+    result: dict[str, Any],
 ) -> bool:
     cache_allowed_requests = provider.cache_allowed_requests
     try:
@@ -143,7 +141,7 @@ def validate_from_blocknum_in_result(
 def validate_from_blockhash_in_params(
     provider: SYNC_PROVIDER_TYPE,
     params: Sequence[Any],
-    _result: Dict[str, Any],
+    _result: dict[str, Any],
 ) -> bool:
     cache_allowed_requests = provider.cache_allowed_requests
     try:
@@ -214,7 +212,7 @@ async def async_is_beyond_validation_threshold(
 async def async_validate_from_block_id_in_params(
     provider: ASYNC_PROVIDER_TYPE,
     params: Sequence[Any],
-    _result: Dict[str, Any],
+    _result: dict[str, Any],
 ) -> bool:
     block_id = params[0]
     if block_id == "earliest":
@@ -228,7 +226,7 @@ async def async_validate_from_block_id_in_params(
 async def async_validate_from_blocknum_in_result(
     provider: ASYNC_PROVIDER_TYPE,
     _params: Sequence[Any],
-    result: Dict[str, Any],
+    result: dict[str, Any],
 ) -> bool:
     cache_allowed_requests = provider.cache_allowed_requests
     try:
@@ -268,7 +266,7 @@ async def async_validate_from_blocknum_in_result(
 
 
 async def async_validate_from_blockhash_in_params(
-    provider: ASYNC_PROVIDER_TYPE, params: Sequence[Any], _result: Dict[str, Any]
+    provider: ASYNC_PROVIDER_TYPE, params: Sequence[Any], _result: dict[str, Any]
 ) -> bool:
     cache_allowed_requests = provider.cache_allowed_requests
     try:

web3/_utils/compat/__init__.py

@@ -11,6 +11,6 @@
 from typing_extensions import (
     NotRequired,  # py311
     Self,  # py311
-    Unpack,  # py311
-    TypeAlias,  # py310
+    Unpack,  # py310
 )
+from typing import TypeAlias

web3/_utils/contract_sources/compile_contracts.py

@@ -47,8 +47,6 @@ import os
 import re
 from typing import (
     Any,
-    Dict,
-    List,
 )
 
 import solcx
@@ -82,7 +80,7 @@ user_filename = user_args.filename
 files_to_compile = [user_filename] if user_filename else all_dot_sol_files
 
 
-def _compile_dot_sol_files(dot_sol_filename: str) -> Dict[str, Any]:
+def _compile_dot_sol_files(dot_sol_filename: str) -> dict[str, Any]:
     compiled = solcx.compile_files(
         [f"./{dot_sol_filename}"],
         output_values=["abi", "bin", "bin-runtime"],
@@ -91,10 +89,10 @@ def _compile_dot_sol_files(dot_sol_filename: str) -> Dict[str, Any]:
 
 
 def _get_compiled_contract_data(
-    sol_file_output: Dict[str, Dict[str, str]],
+    sol_file_output: dict[str, dict[str, str]],
     dot_sol_filename: str,
     contract_name: str = None,
-) -> Dict[str, str]:
+) -> dict[str, str]:
     if not contract_name:
         contract_name = dot_sol_filename.replace(".sol", "")
 
@@ -114,7 +112,7 @@ def _get_compiled_contract_data(
 contracts_in_file = {}
 
 
-def compile_files(file_list: List[str]) -> None:
+def compile_files(file_list: list[str]) -> None:
     for filename in file_list:
         with open(os.path.join(os.getcwd(), filename)) as f:
             dot_sol_file = f.readlines()