Add typing to parity module

Author: kclowes

tests/integration/parity/common.py

@@ -42,39 +42,10 @@ def test_eth_uninstallFilter(self, web3):
         pytest.xfail('eth_uninstallFilter calls to parity always return true')
         super().test_eth_uninstallFilter(web3)
 
-    def test_eth_replaceTransaction(self, web3, unlocked_account):
-        super().test_eth_replaceTransaction(web3, unlocked_account)
-
     @pytest.mark.xfail(reason='Parity is not setup to auto mine')
     def test_eth_replaceTransaction_already_mined(self, web3, unlocked_account):
         super().test_eth_replaceTransaction_already_mined(web3, unlocked_account)
 
-    def test_eth_replaceTransaction_incorrect_nonce(self, web3, unlocked_account):
-        super().test_eth_replaceTransaction_incorrect_nonce(web3, unlocked_account)
-
-    def test_eth_replaceTransaction_gas_price_too_low(self, web3, unlocked_account):
-        super().test_eth_replaceTransaction_gas_price_too_low(web3, unlocked_account)
-
-    def test_eth_replaceTransaction_gas_price_defaulting_minimum(self, web3, unlocked_account):
-        super().test_eth_replaceTransaction_gas_price_defaulting_minimum(web3, unlocked_account)
-
-    def test_eth_replaceTransaction_gas_price_defaulting_strategy_higher(self,
-                                                                         web3,
-                                                                         unlocked_account):
-        super().test_eth_replaceTransaction_gas_price_defaulting_strategy_higher(
-            web3, unlocked_account
-        )
-
-    def test_eth_replaceTransaction_gas_price_defaulting_strategy_lower(self,
-                                                                        web3,
-                                                                        unlocked_account):
-        super().test_eth_replaceTransaction_gas_price_defaulting_strategy_lower(
-            web3, unlocked_account
-        )
-
-    def test_eth_modifyTransaction(self, web3, unlocked_account):
-        super().test_eth_modifyTransaction(web3, unlocked_account)
-
     @flaky(max_runs=MAX_FLAKY_RUNS)
     def test_eth_getTransactionReceipt_unmined(self, web3, unlocked_account):
         # Parity diverges from json-rpc spec and retrieves pending block

web3/_utils/method_formatters.py

@@ -6,6 +6,7 @@
     Collection,
     Dict,
     Iterable,
+    NoReturn,
     Union,
 )
 
@@ -72,6 +73,7 @@
 )
 from web3.types import (
     RPCEndpoint,
+    RPCResponse,
     TReturn,
 )
 
@@ -470,7 +472,7 @@ def apply_list_to_array_formatter(formatter: Any) -> Callable[..., Any]:
 ABI_REQUEST_FORMATTERS = abi_request_formatters(STANDARD_NORMALIZERS, RPC_ABIS)
 
 
-def raise_invalid_parity_mode(response):
+def raise_invalid_parity_mode(response: RPCResponse) -> NoReturn:
     error_message = response['error']['message']
     raise InvalidParityMode(error_message)
 
@@ -479,6 +481,7 @@ def raise_invalid_parity_mode(response):
     RPC.parity_setMode: raise_invalid_parity_mode,
 }
 
+
 @to_tuple
 def combine_formatters(
     formatter_maps: Collection[Dict[RPCEndpoint, Callable[..., TReturn]]], method_name: RPCEndpoint

web3/_utils/module_testing/parity_module.py

@@ -162,6 +162,9 @@ def test_set_mode_with_bad_string(self, web3: "Web3") -> None:
             web3.parity.setMode('not a mode')  # type: ignore
 
     def test_set_mode_with_no_argument(self, web3: "Web3") -> None:
-        with pytest.raises(InvalidParityMode, match='Invalid params: invalid length 0, expected a tuple of size 1.'):
+        with pytest.raises(
+            InvalidParityMode,
+            match='Invalid params: invalid length 0, expected a tuple of size 1.'
+        ):
             # type ignored b/c setMode expects arguments
             web3.parity.setMode()  # type: ignore

web3/method.py

@@ -39,7 +39,7 @@
         ModuleV2,
     )
 
-Munger = Callable[[Union["Module", "ModuleV2"], Any], Any]
+Munger = Callable[..., Any]
 
 
 @to_tuple
@@ -160,7 +160,7 @@ def input_munger(
         mungers_iter = iter(self.mungers)
         root_munger = next(mungers_iter)
         munged_inputs = pipe(
-            root_munger(module, *args, **kwargs),  # type: ignore
+            root_munger(module, *args, **kwargs),
             *map(lambda m: _munger_star_apply(functools.partial(m, module)), mungers_iter))
 
         return munged_inputs

web3/module.py

@@ -99,5 +99,4 @@ def __init__(self, web3: "Web3") -> None:
             self.retrieve_caller_fn = retrieve_async_method_call_fn(web3, self)
         else:
             self.retrieve_caller_fn = retrieve_blocking_method_call_fn(web3, self)
-        #TODO: Think about what this could be. web3.eth? web3.something else?
         self.web3 = web3

web3/parity.py

@@ -1,6 +1,11 @@
 from typing import (
+    Callable,
     List,
     Optional,
+<<<<<<< HEAD
+=======
+    Tuple,
+>>>>>>> Add typing to parity module
     Union,
 )
 
@@ -48,7 +53,6 @@
     default_root_munger,
 )
 from web3.module import (
-    Module,
     ModuleV2,
 )
 from web3.types import (
@@ -129,63 +133,73 @@ class Parity(ModuleV2):
     shh: ParityShh
     personal: ParityPersonal
 
-    enode = Method(
+    enode: Method[Callable[[], str]] = Method(
         RPC.parity_enode,
         mungers=None,
     )
 
     def list_storage_keys_munger(
         self,
-        address: Union[Address, ChecksumAddress, ENS],
+        address: Union[Address, ChecksumAddress, ENS, Hash32],
         quantity: int,
         hash_: Hash32,
+<<<<<<< HEAD
         block_identifier: Optional[BlockIdentifier] = None,
     ) -> List[Hash32]:
+=======
+        block_identifier: Optional[BlockIdentifier]=None,
+    ) -> Tuple[Union[Address, ChecksumAddress, ENS, Hash32], int, Hash32, BlockIdentifier]:
+>>>>>>> Add typing to parity module
         if block_identifier is None:
             block_identifier = self.defaultBlock
-        return [address, quantity, hash_, block_identifier]
+        return (address, quantity, hash_, block_identifier)
 
-    listStorageKeys = Method(
+    listStorageKeys: Method[Callable[..., List[Hash32]]] = Method(
         RPC.parity_listStorageKeys,
         mungers=[list_storage_keys_munger],
     )
 
-    netPeers = Method(
+    netPeers: Method[Callable[[], ParityNetPeers]] = Method(
         RPC.parity_netPeers,
         mungers=None
     )
 
-    addReservedPeer = Method(
+    addReservedPeer: Method[Callable[[EnodeURI], bool]] = Method(
         RPC.parity_addReservedPeer,
         mungers=[default_root_munger],
     )
 
-    def trace_transactions_munger(
-        self, block_identifier: BlockIdentifier, mode: ParityTraceMode=['trace']
-    ) -> List[ParityBlockTrace]:
-        return [block_identifier, mode]
+    def trace_replay_transaction_munger(
+        self, block_identifier: _Hash32, mode: ParityTraceMode=['trace']
+    ) -> Tuple[Union[BlockIdentifier, _Hash32], ParityTraceMode]:
+        return (block_identifier, mode)
 
-    traceReplayTransaction = Method(
+    traceReplayTransaction: Method[Callable[..., ParityBlockTrace]] = Method(
         RPC.trace_replayTransaction,
-        mungers=[trace_transactions_munger],
+        mungers=[trace_replay_transaction_munger],
     )
 
-    traceReplayBlockTransactions = Method(
+    def trace_replay_block_transactions_munger(
+        self, block_identifier: BlockIdentifier, mode: ParityTraceMode=['trace']
+    ) -> Tuple[BlockIdentifier, ParityTraceMode]:
+        return (block_identifier, mode)
+
+    traceReplayBlockTransactions: Method[Callable[..., List[ParityBlockTrace]]] = Method(
         RPC.trace_replayBlockTransactions,
-        mungers=[trace_transactions_munger]
+        mungers=[trace_replay_block_transactions_munger]
     )
 
-    traceBlock = Method(
+    traceBlock: Method[Callable[[BlockIdentifier], List[ParityBlockTrace]]] = Method(
         RPC.trace_block,
         mungers=[default_root_munger],
     )
 
-    traceFilter = Method(
+    traceFilter: Method[Callable[[ParityFilterParams], List[ParityFilterTrace]]] = Method(
         RPC.trace_filter,
         mungers=[default_root_munger],
     )
 
-    traceTransaction = Method(
+    traceTransaction: Method[Callable[[_Hash32], List[ParityFilterTrace]]] = Method(
         RPC.trace_transaction,
         mungers=[default_root_munger],
     )
@@ -194,33 +208,39 @@ def trace_call_munger(
         self,
         transaction: TxParams,
         mode: ParityTraceMode=['trace'],
-        block_identifier: BlockIdentifier=None
-    ) -> ParityBlockTrace:
+        block_identifier: Optional[BlockIdentifier]=None
+    ) -> Tuple[TxParams, ParityTraceMode, BlockIdentifier]:
+        # TODO: move to middleware
         if 'from' not in transaction and is_checksum_address(self.web3.eth.defaultAccount):
             transaction = assoc(transaction, 'from', self.web3.eth.defaultAccount)
 
         # TODO: move to middleware
         if block_identifier is None:
             block_identifier = self.defaultBlock
 
-        return [transaction, mode, block_identifier]
+        return (transaction, mode, block_identifier)
 
-    traceCall = Method(
+    traceCall: Method[Callable[..., ParityBlockTrace]] = Method(
         RPC.trace_call,
         mungers=[trace_call_munger],
     )
 
-    traceRawTransaction = Method(
+    def trace_transactions_munger(
+        self, raw_transaction: HexStr, mode: ParityTraceMode=['trace']
+    ) -> Tuple[HexStr, ParityTraceMode]:
+        return (raw_transaction, mode)
+
+    traceRawTransaction: Method[Callable[..., ParityBlockTrace]] = Method(
         RPC.trace_rawTransaction,
         mungers=[trace_transactions_munger],
     )
 
-    setMode = Method(
+    setMode: Method[Callable[[ParityMode], bool]] = Method(
         RPC.parity_setMode,
         mungers=[default_root_munger],
     )
 
-    mode = Method(
+    mode: Method[Callable[[], ParityMode]] = Method(
         RPC.parity_mode,
         mungers=None
     )