Move Parity module to use Method class

Author: kclowes

tests/integration/parity/test_parity_http.py

@@ -16,7 +16,9 @@
 from .common import (
     CommonParityShhModuleTest,
     ParityEthModuleTest,
+    ParityModuleTest,
     ParityPersonalModuleTest,
+    ParitySetModuleTest,
     ParityTraceModuleTest,
     ParityWeb3ModuleTest,
 )
@@ -88,6 +90,10 @@ class TestParityEthModuleTest(ParityEthModuleTest):
     pass
 
 
+class TestParityModuleTest(ParityModuleTest):
+    pass
+
+
 class TestParityVersionModule(VersionModuleTest):
     pass
 
@@ -106,3 +112,7 @@ class TestParityTraceModuleTest(ParityTraceModuleTest):
 
 class TestParityShhModuleTest(CommonParityShhModuleTest):
     pass
+
+
+class TestParitySetModuleTest(ParitySetModuleTest):
+    pass

web3/_utils/method_formatters.py

@@ -67,6 +67,9 @@
 from web3.datastructures import (
     AttributeDict,
 )
+from web3.exceptions import (
+    InvalidParityMode,
+)
 from web3.types import (
     RPCEndpoint,
     TReturn,
@@ -467,6 +470,15 @@ 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):
+    error_message = response['error']['message']
+    raise InvalidParityMode(error_message)
+
+
+ERROR_FORMATTERS = {
+    RPC.parity_setMode: raise_invalid_parity_mode,
+}
+
 @to_tuple
 def combine_formatters(
     formatter_maps: Collection[Dict[RPCEndpoint, Callable[..., TReturn]]], method_name: RPCEndpoint
@@ -505,7 +517,7 @@ def get_error_formatters(
 ) -> Dict[str, Callable[..., Any]]:
     #  Note error formatters work on the full response dict
     # TODO - test this function
-    error_formatter_maps = ()
+    error_formatter_maps = (ERROR_FORMATTERS,)
     formatters = combine_formatters(error_formatter_maps, method_name)
 
     return compose(*formatters)

web3/_utils/module_testing/parity_module.py

@@ -15,6 +15,9 @@
 from web3._utils.formatters import (
     hex_to_integer,
 )
+from web3.exceptions import (
+    InvalidParityMode,
+)
 from web3.types import (
     BlockData,
     EnodeURI,
@@ -154,11 +157,11 @@ def test_set_mode(self, web3: "Web3", mode: ParityMode) -> None:
         assert web3.parity.setMode(mode) is True
 
     def test_set_mode_with_bad_string(self, web3: "Web3") -> None:
-        with pytest.raises(ValueError, match="Couldn't parse parameters: mode"):
+        with pytest.raises(InvalidParityMode, match="Couldn't parse parameters: mode"):
             # type ignored b/c it's an invalid literal ParityMode
             web3.parity.setMode('not a mode')  # type: ignore
 
     def test_set_mode_with_no_argument(self, web3: "Web3") -> None:
-        with pytest.raises(TypeError, match='missing 1 required positional argument'):
+        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/exceptions.py

@@ -192,3 +192,11 @@ class InvalidEventABI(ValueError):
     Raised when the event ABI is invalid.
     """
     pass
+
+
+class InvalidParityMode(TypeError, ValueError):
+    # Inherits from TypeError for backwards compatibility
+    """
+    Raised when web3.parity.setMode() is called with no args
+    """
+    pass

web3/module.py

@@ -99,3 +99,5 @@ 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

@@ -43,6 +43,10 @@
 from web3._utils.rpc_abi import (
     RPC,
 )
+from web3.method import (
+    Method,
+    default_root_munger,
+)
 from web3.module import (
     Module,
     ModuleV2,
@@ -117,21 +121,20 @@ class ParityPersonal(ModuleV2):
     unlockAccount = unlockAccount
 
 
-class Parity(Module):
+class Parity(ModuleV2):
     """
     https://paritytech.github.io/wiki/JSONRPC-parity-module
     """
     defaultBlock: Literal["latest"] = "latest"  # noqa: E704
     shh: ParityShh
     personal: ParityPersonal
 
-    def enode(self) -> EnodeURI:
-        return self.web3.manager.request_blocking(
-            RPC.parity_enode,
-            [],
-        )
+    enode = Method(
+        RPC.parity_enode,
+        mungers=None,
+    )
 
-    def listStorageKeys(
+    def list_storage_keys_munger(
         self,
         address: Union[Address, ChecksumAddress, ENS],
         quantity: int,
@@ -140,91 +143,84 @@ def listStorageKeys(
     ) -> List[Hash32]:
         if block_identifier is None:
             block_identifier = self.defaultBlock
-        return self.web3.manager.request_blocking(
-            RPC.parity_listStorageKeys,
-            [address, quantity, hash_, block_identifier],
-        )
-
-    def netPeers(self) -> ParityNetPeers:
-        return self.web3.manager.request_blocking(
-            RPC.parity_netPeers,
-            [],
-        )
-
-    def addReservedPeer(self, url: EnodeURI) -> bool:
-        return self.web3.manager.request_blocking(
-            RPC.parity_addReservedPeer,
-            [url],
-        )
-
-    def traceReplayTransaction(
-        self, transaction_hash: _Hash32, mode: ParityTraceMode=['trace']
-    ) -> ParityBlockTrace:
-        return self.web3.manager.request_blocking(
-            RPC.trace_replayTransaction,
-            [transaction_hash, mode],
-        )
+        return [address, quantity, hash_, block_identifier]
+
+    listStorageKeys = Method(
+        RPC.parity_listStorageKeys,
+        mungers=[list_storage_keys_munger],
+    )
 
-    def traceReplayBlockTransactions(
+    netPeers = Method(
+        RPC.parity_netPeers,
+        mungers=None
+    )
+
+    addReservedPeer = Method(
+        RPC.parity_addReservedPeer,
+        mungers=[default_root_munger],
+    )
+
+    def trace_transactions_munger(
         self, block_identifier: BlockIdentifier, mode: ParityTraceMode=['trace']
     ) -> List[ParityBlockTrace]:
-        return self.web3.manager.request_blocking(
-            RPC.trace_replayBlockTransactions,
-            [block_identifier, mode]
-        )
-
-    def traceBlock(self, block_identifier: BlockIdentifier) -> List[ParityBlockTrace]:
-        return self.web3.manager.request_blocking(
-            RPC.trace_block,
-            [block_identifier]
-        )
-
-    def traceFilter(self, params: ParityFilterParams) -> List[ParityFilterTrace]:
-        return self.web3.manager.request_blocking(
-            RPC.trace_filter,
-            [params]
-        )
-
-    def traceTransaction(self, transaction_hash: _Hash32) -> List[ParityFilterTrace]:
-        return self.web3.manager.request_blocking(
-            RPC.trace_transaction,
-            [transaction_hash]
-        )
-
-    def traceCall(
+        return [block_identifier, mode]
+
+    traceReplayTransaction = Method(
+        RPC.trace_replayTransaction,
+        mungers=[trace_transactions_munger],
+    )
+
+    traceReplayBlockTransactions = Method(
+        RPC.trace_replayBlockTransactions,
+        mungers=[trace_transactions_munger]
+    )
+
+    traceBlock = Method(
+        RPC.trace_block,
+        mungers=[default_root_munger],
+    )
+
+    traceFilter = Method(
+        RPC.trace_filter,
+        mungers=[default_root_munger],
+    )
+
+    traceTransaction = Method(
+        RPC.trace_transaction,
+        mungers=[default_root_munger],
+    )
+
+    def trace_call_munger(
         self,
         transaction: TxParams,
         mode: ParityTraceMode=['trace'],
-        block_identifier: Optional[BlockIdentifier] = None
+        block_identifier: BlockIdentifier=None
     ) -> ParityBlockTrace:
-        # 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 self.web3.manager.request_blocking(
-            RPC.trace_call,
-            [transaction, mode, block_identifier],
-        )
 
-    def traceRawTransaction(
-        self, raw_transaction: HexStr, mode: ParityTraceMode=['trace']
-    ) -> ParityBlockTrace:
-        return self.web3.manager.request_blocking(
-            RPC.trace_rawTransaction,
-            [raw_transaction, mode],
-        )
-
-    def setMode(self, mode: ParityMode) -> bool:
-        return self.web3.manager.request_blocking(
-            RPC.parity_setMode,
-            [mode]
-        )
-
-    def mode(self) -> ParityMode:
-        return self.web3.manager.request_blocking(
-            RPC.parity_mode,
-            []
-        )
+        return [transaction, mode, block_identifier]
+
+    traceCall = Method(
+        RPC.trace_call,
+        mungers=[trace_call_munger],
+    )
+
+    traceRawTransaction = Method(
+        RPC.trace_rawTransaction,
+        mungers=[trace_transactions_munger],
+    )
+
+    setMode = Method(
+        RPC.parity_setMode,
+        mungers=[default_root_munger],
+    )
+
+    mode = Method(
+        RPC.parity_mode,
+        mungers=None
+    )