Enable Type Hinting for eth.tools completely

Author: Bhargavasomu

eth/tools/_utils/hashing.py

@@ -7,10 +7,14 @@
     Tuple,
 )
 
+from eth_typing import (
+    Hash32,
+)
+
 from eth.rlp.logs import Log
 
 
-def hash_log_entries(log_entries: Iterable[Tuple[bytes, bytes, bytes]]) -> bytes:
+def hash_log_entries(log_entries: Iterable[Tuple[bytes, bytes, bytes]]) -> Hash32:
     """
     Helper function for computing the RLP hash of the logs from transaction
     execution.

eth/tools/_utils/mappings.py

@@ -10,7 +10,7 @@
 from cytoolz import merge_with
 
 
-def merge_if_dicts(values: Sequence[Any]) -> Any:
+def merge_if_dicts(values: Sequence[Dict[Any, Any]]) -> Any:
     if all(isinstance(item, Mapping) for item in values):
         return merge_with(merge_if_dicts, *values)
     else:

eth/tools/_utils/normalization.py

@@ -1,16 +1,14 @@
 import binascii
-from collections.abc import (
-    Iterable,
-    Mapping,
-)
 import functools
 
 from typing import (
     Any,
     AnyStr,
     Callable,
     Dict,
+    Iterable,
     List,
+    Mapping,
     Sequence,
     Tuple,
 )
@@ -58,6 +56,8 @@
 from eth.typing import (
     AccountState,
     GeneralState,
+    NormalizerType,
+    TransactionDict,
 )
 
 
@@ -97,7 +97,7 @@ def normalize_bytes(value: Any) -> bytes:
 
 
 @functools.lru_cache(maxsize=1024)
-def to_int(value: Any) -> int:
+def to_int(value: str) -> int:
     """
     Robust to integer conversion, handling hex values, string representations,
     and special cases like `0x`.
@@ -125,26 +125,22 @@ def normalize_to_address(value: AnyStr) -> Address:
 #
 # Containers
 #
-
-NormalizerType = Callable[[Dict[Any, Any]], Iterable[Tuple[Any, Any]]]
-
-
-def dict_normalizer(formatters: Dict[Any, Any],
+def dict_normalizer(formatters: Dict[Any, Callable[..., Any]],
                     required: Iterable[Any]=None,
                     optional: Iterable[Any]=None) -> NormalizerType:
 
     all_keys = set(formatters.keys())
 
     if required is None and optional is None:
         required_set_form = all_keys
+    elif required is not None and optional is not None:
+        raise ValueError("Both required and optional keys specified")
     elif required is not None:
         required_set_form = set(required)
     elif optional is not None:
         required_set_form = all_keys - set(optional)
-    else:
-        raise ValueError("Both required and optional keys specified")
 
-    def normalizer(d: Dict[Any, Any]) -> Iterable[Tuple[Any, Any]]:
+    def normalizer(d: Dict[Any, Any]) -> Dict[str, Any]:
         keys = set(d.keys())
         missing_keys = required_set_form - keys
         superfluous_keys = keys - all_keys
@@ -158,9 +154,9 @@ def normalizer(d: Dict[Any, Any]) -> Iterable[Tuple[Any, Any]]:
     return normalizer
 
 
-def dict_options_normalizer(normalizers: Iterable[Callable[..., Any]]) -> Callable[..., Any]:
+def dict_options_normalizer(normalizers: Iterable[NormalizerType]) -> NormalizerType:
 
-    def normalize(d: Dict[Any, Any]) -> Callable[..., Any]:
+    def normalize(d: Dict[Any, Any]) -> Dict[str, Any]:
         first_exception = None
         for normalizer in normalizers:
             try:
@@ -251,36 +247,36 @@ def state_definition_to_dict(state_definition: GeneralState) -> AccountState:
 )
 
 
-normalize_main_transaction = dict_normalizer({
+normalize_main_transaction = dict_normalizer({    # type: ignore # Overwrite type hint not yet supported # noqa: 501
     "data": normalize_bytes,
     "gasLimit": normalize_int,
     "gasPrice": normalize_int,
     "nonce": normalize_int,
     "secretKey": normalize_bytes,
     "to": normalize_to_address,
     "value": normalize_int,
-})
+})  # type: TransactionNormalizer
 
 
-normalize_transaction = dict_options_normalizer([
+normalize_transaction = dict_options_normalizer([  # type: ignore # Overwrite type hint not yet supported # noqa: 501
     normalize_main_transaction,
-])
+])  # type: TransactionNormalizer
 
 
-normalize_main_transaction_group = dict_normalizer({
+normalize_main_transaction_group = dict_normalizer({   # type: ignore # Overwrite type hint not yet supported # noqa: 501
     "data": eth_utils.curried.apply_formatter_to_array(normalize_bytes),
     "gasLimit": eth_utils.curried.apply_formatter_to_array(normalize_int),
     "gasPrice": normalize_int,
     "nonce": normalize_int,
     "secretKey": normalize_bytes,
     "to": normalize_to_address,
     "value": eth_utils.curried.apply_formatter_to_array(normalize_int),
-})
+})  # type: TransactionNormalizer
 
 
-normalize_transaction_group = dict_options_normalizer([
+normalize_transaction_group = dict_options_normalizer([   # type: ignore # Overwrite type hint not yet supported # noqa: 501
     normalize_main_transaction_group,
-])
+])  # type: TransactionNormalizer
 
 
 normalize_execution = dict_normalizer({
@@ -331,12 +327,12 @@ def state_definition_to_dict(state_definition: GeneralState) -> AccountState:
 #
 # Fixture Normalizers
 #
-def normalize_unsigned_transaction(transaction: Dict[str, Any],
-                                   indexes: Dict[str, Any]) -> Dict[str, Any]:
+def normalize_unsigned_transaction(transaction: TransactionDict,
+                                   indexes: Dict[str, Any]) -> TransactionDict:
 
-    normalized = normalize_transaction_group(transaction)
+    normalized = normalize_transaction_group(transaction)   # type: TransactionDict
     return merge(normalized, {
-        transaction_key: normalized[transaction_key][indexes[index_key]]
+        transaction_key: normalized[transaction_key][indexes[index_key]]    # type: ignore # https://github.com/python/mypy/issues/5359 # noqa: 501
         for transaction_key, index_key in [
             ("gasLimit", "gas"),
             ("value", "value"),

eth/tools/_utils/vyper.py

@@ -4,6 +4,7 @@
     Any,
     Callable,
     Dict,
+    List,
     Tuple,
 )
 
@@ -30,7 +31,7 @@ def inner(*args: Any, **kwargs: Any) -> Any:
 
 
 @require_vyper
-def compile_vyper_lll(vyper_code: Any) -> Tuple[bytes, Dict[str, Any]]:
+def compile_vyper_lll(vyper_code: List[Any]) -> Tuple[bytes, Dict[str, Any]]:
     lll_node = LLLnode.from_list(vyper_code)
     assembly = compile_to_assembly(lll_node)
     code = assembly_to_evm(assembly)

eth/tools/builder/chain/builders.py

@@ -92,23 +92,23 @@ def build(obj: Any, *applicators: Callable[..., Any]) -> Any:
 # Constructors (creation of chain classes)
 #
 @curry
-def name(class_name: str, chain_class: BaseChain) -> type:
+def name(class_name: str, chain_class: Type[BaseChain]) -> Type[BaseChain]:
     """
     Assign the given name to the chain class.
     """
     return chain_class.configure(__name__=class_name)
 
 
 @curry
-def chain_id(chain_id: int, chain_class: BaseChain) -> type:
+def chain_id(chain_id: int, chain_class: Type[BaseChain]) -> Type[BaseChain]:
     """
     Set the ``chain_id`` for the chain class.
     """
     return chain_class.configure(chain_id=chain_id)
 
 
 @curry
-def fork_at(vm_class: Type[BaseVM], at_block: int, chain_class: BaseChain) -> type:
+def fork_at(vm_class: Type[BaseVM], at_block: int, chain_class: Type[BaseChain]) -> Type[BaseChain]:
     """
     Adds the ``vm_class`` to the chain's ``vm_configuration``.
 
@@ -168,7 +168,7 @@ def _set_vm_dao_support_false(vm_configuration: VMConfiguration) -> VMConfigurat
 
 
 @curry
-def disable_dao_fork(chain_class: BaseChain) -> type:
+def disable_dao_fork(chain_class: Type[BaseChain]) -> Type[BaseChain]:
     """
     Set the ``support_dao_fork`` flag to ``False`` on the
     :class:`~eth.vm.forks.homestead.HomesteadVM`.  Requires that presence of
@@ -199,7 +199,7 @@ def _set_vm_dao_fork_block_number(dao_fork_block_number: int,
 
 
 @curry
-def dao_fork_at(dao_fork_block_number: int, chain_class: BaseChain) -> type:
+def dao_fork_at(dao_fork_block_number: int, chain_class: Type[BaseChain]) -> Type[BaseChain]:
     """
     Set the block number on which the DAO fork will happen.  Requires that a
     version of the :class:`~eth.vm.forks.homestead.HomesteadVM` is present in
@@ -263,7 +263,7 @@ def _mix_in_pow_mining(vm_configuration: VMConfiguration) -> VMConfiguration:
 
 
 @curry
-def enable_pow_mining(chain_class: BaseChain) -> type:
+def enable_pow_mining(chain_class: Type[BaseChain]) -> Type[BaseChain]:
     """
     Inject on demand generation of the proof of work mining seal on newly
     mined blocks into each of the chain's vms.
@@ -299,7 +299,7 @@ def _mix_in_disable_seal_validation(vm_configuration: VMConfiguration) -> VMConf
 
 
 @curry
-def disable_pow_check(chain_class: Type[BaseChain]) -> type:
+def disable_pow_check(chain_class: Type[BaseChain]) -> Type[BaseChain]:
     """
     Disable the proof of work validation check for each of the chain's vms.
     This allows for block mining without generation of the proof of work seal.

eth/tools/fixtures/_utils.py

@@ -2,20 +2,26 @@
 import functools
 import os
 
+from typing import (
+    Any,
+    Callable,
+    Iterable,
+)
+
 from eth_utils import to_tuple
 
 
 @to_tuple
-def recursive_find_files(base_dir, pattern):
+def recursive_find_files(base_dir: str, pattern: str) -> Iterable[str]:
     for dirpath, _, filenames in os.walk(base_dir):
         for filename in filenames:
             if fnmatch.fnmatch(filename, pattern):
                 yield os.path.join(dirpath, filename)
 
 
-def require_pytest(fn):
+def require_pytest(fn: Callable[..., Any]) -> Callable[..., Any]:
     @functools.wraps(fn)
-    def inner(*args, **kwargs):
+    def inner(*args: Any, **kwargs: Any) -> Callable[..., Any]:
         try:
             import pytest  # noqa: F401
         except ImportError:

eth/tools/fixtures/fillers/_utils.py

@@ -1,11 +1,29 @@
 import copy
 import random
 
+from typing import (
+    Any,
+    Dict,
+    List,
+    Tuple,
+    Type,
+)
+
+from eth_typing import (
+    Address,
+)
+
 from eth_utils import (
     int_to_big_endian,
 )
 
 from eth.db.backends.memory import MemoryDB
+from eth.db.account import BaseAccountDB
+
+from eth.typing import (
+    AccountState,
+    TransactionDict,
+)
 
 from eth.utils.db import (
     apply_state_dict,
@@ -17,13 +35,15 @@
 from eth_keys import keys
 
 
-def wrap_in_list(item):
+def wrap_in_list(item: Any) -> List[Any]:
     return [item]
 
 
-def add_transaction_to_group(group, transaction):
+def add_transaction_to_group(group: Dict[str, Any],
+                             transaction: TransactionDict) -> Tuple[Dict[str, Any], Dict[str, int]]:
+
     for key in ["gasPrice", "nonce", "secretKey", "to"]:
-        if key in transaction and transaction[key] != group[key]:
+        if key in transaction and transaction[key] != group[key]:   # type: ignore # https://github.com/python/mypy/issues/5359 # noqa: 501
             raise ValueError("Can't add transaction as it differs in {}".format(key))
 
     new_group = copy.deepcopy(group)
@@ -35,26 +55,26 @@ def add_transaction_to_group(group, transaction):
                     raise ValueError("Can't add transaction as {} is ambiguous".format(key))
                 index = 0
             else:
-                if transaction[key] not in new_group[key]:
-                    new_group[key].append(transaction[key])
-                index = new_group[key].index(transaction[key])
+                if transaction[key] not in new_group[key]:      # type: ignore # https://github.com/python/mypy/issues/5359 # noqa: 501
+                    new_group[key].append(transaction[key])     # type: ignore # https://github.com/python/mypy/issues/5359 # noqa: 501
+                index = new_group[key].index(transaction[key])  # type: ignore # https://github.com/python/mypy/issues/5359 # noqa: 501
             indexes[index_key] = index
         else:
             assert key not in transaction
     return new_group, indexes
 
 
-def calc_state_root(state, account_db_class):
+def calc_state_root(state: AccountState, account_db_class: Type[BaseAccountDB]) -> bytes:
     account_db = account_db_class(MemoryDB())
     apply_state_dict(account_db, state)
     return account_db.state_root
 
 
-def generate_random_keypair():
+def generate_random_keypair() -> Tuple[bytes, Address]:
     key_object = keys.PrivateKey(pad32(int_to_big_endian(random.getrandbits(8 * 32))))
     return key_object.to_bytes(), key_object.public_key.to_canonical_address()
 
 
-def generate_random_address():
+def generate_random_address() -> Address:
     _, address = generate_random_keypair()
     return address