Move filter to use Method class

Author: kclowes

newsfragments/1778.misc.rst

@@ -0,0 +1 @@
+Move eth.filter method to use ``Method`` class

tests/core/filtering/test_contract_past_event_filtering.py

@@ -4,9 +4,6 @@
     is_same_address,
 )
 
-# Ignore warning in pyethereum 1.6 - will go away with the upgrade
-pytestmark = pytest.mark.filterwarnings("ignore:implicit cast from 'char *'")
-
 
 @pytest.mark.parametrize('call_as_instance', (True, False))
 @pytest.mark.parametrize('api_style', ('v4', 'build_filter'))

tests/core/filtering/test_existing_filter_instance.py

@@ -17,7 +17,7 @@ def filter_id(web3):
     return block_filter.filter_id
 
 
-def test_instatiate_existing_filter(web3, sleep_interval, wait_for_block, filter_id):
+def test_instantiate_existing_filter(web3, sleep_interval, wait_for_block, filter_id):
     with pytest.raises(TypeError):
         web3.eth.filter('latest', filter_id)
     with pytest.raises(TypeError):

tests/core/filtering/test_filters_against_many_blocks.py

@@ -79,8 +79,7 @@ def test_block_filter(web3):
     assert len(block_filter.get_new_entries()) == web3.eth.blockNumber
 
 
-def test_transaction_filter_with_mining(
-        web3):
+def test_transaction_filter_with_mining(web3):
 
     transaction_filter = web3.eth.filter("pending")
 

tests/core/filtering/test_utils_functions.py

@@ -131,7 +131,7 @@
 def test_match_fn_with_various_data_types(web3, data, expected, match_data_and_abi):
     abi_types, match_data = zip(*match_data_and_abi)
     encoded_data = web3.codec.encode_abi(abi_types, data)
-    assert match_fn(web3, match_data_and_abi, encoded_data) == expected
+    assert match_fn(web3.codec, match_data_and_abi, encoded_data) == expected
 
 
 @pytest.mark.parametrize(
@@ -206,7 +206,7 @@ def test_match_fn_with_various_data_types_strict(w3_strict_abi,
                                                  match_data_and_abi):
     abi_types, match_data = zip(*match_data_and_abi)
     encoded_data = w3_strict_abi.codec.encode_abi(abi_types, data)
-    assert match_fn(w3_strict_abi, match_data_and_abi, encoded_data) == expected
+    assert match_fn(w3_strict_abi.codec, match_data_and_abi, encoded_data) == expected
 
 
 @pytest.mark.parametrize(
@@ -233,4 +233,4 @@ def test_wrong_type_match_data(web3):
     abi_types, match_data = zip(*match_data_and_abi)
     encoded_data = web3.codec.encode_abi(abi_types, data)
     with pytest.raises(ValueError):
-        match_fn(web3, match_data_and_abi, encoded_data)
+        match_fn(web3.codec, match_data_and_abi, encoded_data)

tests/core/method-class/test_method.py

@@ -54,7 +54,7 @@ def test_get_formatters_default_formatter_for_falsy_config():
     )
 
     default_request_formatters = method.request_formatters(method.method_selector_fn())
-    default_result_formatters = method.result_formatters(method.method_selector_fn())
+    default_result_formatters = method.result_formatters(method.method_selector_fn(), 'some module')
     assert _apply_request_formatters(['a', 'b', 'c'], default_request_formatters) == ('a', 'b', 'c')
     assert apply_result_formatters(
         default_result_formatters, ['a', 'b', 'c']) == ['a', 'b', 'c']

tests/core/method-class/test_result_formatters.py

@@ -19,7 +19,7 @@
 )
 
 
-def result_formatter(method):
+def result_formatter(method, module):
     def formatter(self):
         return 'OKAY'
     return compose(formatter)

tests/core/middleware/test_filter_middleware.py

@@ -23,10 +23,7 @@
 
 class DummyProvider(BaseProvider):
     def make_request(self, method, params):
-        raise NotImplementedError("Cannot make request for {0}:{1}".format(
-            method,
-            params,
-        ))
+        raise NotImplementedError(f"Cannot make request for {method}:{params}")
 
 
 BLOCK_HASH = '0xfe88c94d860f01a17f961bf4bdfb6e0c6cd10d3fda5cc861e805ca1240c58553'

tests/core/utilities/test_select_filter_method.py

@@ -0,0 +1,38 @@
+import pytest
+
+from web3._utils.filters import (
+    _UseExistingFilter,
+    select_filter_method,
+)
+from web3.exceptions import (
+    ValidationError,
+)
+
+
+@pytest.mark.parametrize('value, expected', (
+    ('latest', 'new_block_filter'),
+    ('pending', 'new_pending_tx_filter'),
+    ({'to': '0x' + '00' * 20}, 'new_filter'),
+))
+def test_select_filter_method(value, expected):
+    filter_method = select_filter_method(
+        if_new_block_filter='new_block_filter',
+        if_new_pending_transaction_filter='new_pending_tx_filter',
+        if_new_filter='new_filter',
+    )
+    assert filter_method(value) == expected
+
+
+@pytest.mark.parametrize('value, error', (
+    ('0x0', _UseExistingFilter),
+    ('disallowed string', ValidationError),
+    (1, ValidationError),  # filter id needs to be a hexstr
+))
+def test_select_filter_method_raises_error(value, error):
+    filter_method = select_filter_method(
+        if_new_block_filter='new_block_filter',
+        if_new_pending_transaction_filter='new_pending_tx_filter',
+        if_new_filter='new_filter',
+    )
+    with pytest.raises(error):
+        filter_method(value)

web3/_utils/filters.py

@@ -9,6 +9,7 @@
     Optional,
     Sequence,
     Tuple,
+    Union,
 )
 
 from eth_abi.codec import (
@@ -23,6 +24,7 @@
     TypeStr,
 )
 from eth_utils import (
+    is_hex,
     is_list_like,
     is_string,
     is_text,
@@ -46,15 +48,24 @@
 from web3._utils.validation import (
     validate_address,
 )
+from web3.exceptions import (
+    ValidationError,
+)
 from web3.types import (
     ABIEvent,
     BlockIdentifier,
     FilterParams,
     LogReceipt,
+    RPCEndpoint,
 )
 
 if TYPE_CHECKING:
     from web3 import Web3  # noqa: F401
+    from web3.module import (  # noqa: F401
+        Module,
+        ModuleV2,
+    )
+    from web3.eth import Eth  # noqa: F401
 
 
 def construct_event_filter_params(
@@ -122,14 +133,16 @@ class Filter:
     poll_interval = None
     filter_id = None
 
-    def __init__(self, web3: "Web3", filter_id: HexStr) -> None:
-        self.web3 = web3
+    def __init__(self,
+                 filter_id: HexStr,
+                 eth_module: "Eth") -> None:
+        self.eth_module = eth_module
         self.filter_id = filter_id
         self.callbacks = []
         super().__init__()
 
     def __str__(self) -> str:
-        return "Filter for {0}".format(self.filter_id)
+        return f"Filter for {self.filter_id}"
 
     def format_entry(self, entry: LogReceipt) -> LogReceipt:
         """
@@ -148,11 +161,11 @@ def _filter_valid_entries(self, entries: Collection[LogReceipt]) -> Iterator[Log
         return filter(self.is_valid_entry, entries)
 
     def get_new_entries(self) -> List[LogReceipt]:
-        log_entries = self._filter_valid_entries(self.web3.eth.getFilterChanges(self.filter_id))
+        log_entries = self._filter_valid_entries(self.eth_module.getFilterChanges(self.filter_id))
         return self._format_log_entries(log_entries)
 
     def get_all_entries(self) -> List[LogReceipt]:
-        log_entries = self._filter_valid_entries(self.web3.eth.getFilterLogs(self.filter_id))
+        log_entries = self._filter_valid_entries(self.eth_module.getFilterLogs(self.filter_id))
         return self._format_log_entries(log_entries)
 
     def _format_log_entries(self,
@@ -203,7 +216,7 @@ def set_data_filters(self, data_filter_set: Collection[Tuple[TypeStr, Any]]) ->
         """
         self.data_filter_set = data_filter_set
         if any(data_filter_set):
-            self.data_filter_set_function = match_fn(self.web3, data_filter_set)
+            self.data_filter_set_function = match_fn(self.eth_module.codec, data_filter_set)
 
     def is_valid_entry(self, entry: LogReceipt) -> bool:
         if not self.data_filter_set:
@@ -235,21 +248,21 @@ def normalize_data_values(type_string: TypeStr, data_value: Any) -> Any:
 
 
 @curry
-def match_fn(w3: "Web3", match_values_and_abi: Collection[Tuple[str, Any]], data: Any) -> bool:
+def match_fn(codec: ABICodec, match_values_and_abi: Collection[Tuple[str, Any]], data: Any) -> bool:
     """Match function used for filtering non-indexed event arguments.
 
     Values provided through the match_values_and_abi parameter are
     compared to the abi decoded log data.
     """
     abi_types, all_match_values = zip(*match_values_and_abi)
 
-    decoded_values = w3.codec.decode_abi(abi_types, HexBytes(data))
+    decoded_values = codec.decode_abi(abi_types, HexBytes(data))
     for data_value, match_values, abi_type in zip(decoded_values, all_match_values, abi_types):
         if match_values is None:
             continue
         normalized_data = normalize_data_values(abi_type, data_value)
         for value in match_values:
-            if not w3.is_encodable(abi_type, value):
+            if not codec.is_encodable(abi_type, value):
                 raise ValueError(
                     f"Value {value} is of the wrong abi type. "
                     f"Expected {abi_type} typed value."
@@ -260,3 +273,41 @@ def match_fn(w3: "Web3", match_values_and_abi: Collection[Tuple[str, Any]], data
             return False
 
     return True
+
+
+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:
+        self.filter_id = filter_id
+
+
+@curry
+def select_filter_method(
+    value: Union[str, FilterParams, HexStr],
+    if_new_block_filter: RPCEndpoint,
+    if_new_pending_transaction_filter: RPCEndpoint,
+    if_new_filter: RPCEndpoint,
+) -> RPCEndpoint:
+
+    if is_string(value):
+        if value == "latest":
+            return if_new_block_filter
+        elif value == "pending":
+            return if_new_pending_transaction_filter
+        elif is_hex(value):
+            raise _UseExistingFilter(value)
+        else:
+            raise ValidationError("Filter argument needs to be either 'latest',"
+                                  " 'pending', or a hex-encoded filter_id. Filter argument"
+                                  f" is: {value}")
+    elif isinstance(value, dict):
+        return if_new_filter
+    else:
+        raise ValidationError("Filter argument needs to be either the string "
+                              "'pending' or 'latest', a filter_id, "
+                              f"or a filter params dictionary. Filter argument is: {value}")