Remove AttributeDict method formatters and opt for middleware

- ``AttributeDict`` leads to typing complications when properties are accessed via attribute, rather than key / value. This doesn't complicate too much since a user can opt for key / value every time but it isn't ideal to provide an option that breaks typing. Those who wish to turn off all recursive conversion to ``AttributeDict`` can simply remove the ``attrdict_middleware`` (or ``async_attrdict_middleware``) and not worry about possible typing complications.

- In order for this to work for async as well, support for ``async_attrdict_middleware` was introduced. This is also now one of the default middlewares for the ``EthereumTesterProvider`` as this was the default behavior achieved via the result formatters.

Author: fselmo

tests/core/contracts/test_extracting_event_data.py

@@ -579,9 +579,8 @@ def test_event_rich_log(
         raise Exception("Unreachable!")
 
     assert rich_log["args"] == expected_args
-    assert rich_log.args == expected_args
     for arg in expected_args:
-        assert getattr(rich_log.args, arg) == expected_args[arg]
+        assert rich_log["args"][arg] == expected_args[arg]
     assert rich_log["blockHash"] == txn_receipt["blockHash"]
     assert rich_log["blockNumber"] == txn_receipt["blockNumber"]
     assert rich_log["transactionIndex"] == txn_receipt["transactionIndex"]
@@ -842,9 +841,8 @@ def test_event_rich_log_non_strict(
         raise Exception("Unreachable!")
 
     assert rich_log["args"] == expected_args
-    assert rich_log.args == expected_args
     for arg in expected_args:
-        assert getattr(rich_log.args, arg) == expected_args[arg]
+        assert rich_log["args"][arg] == expected_args[arg]
     assert rich_log["blockHash"] == txn_receipt["blockHash"]
     assert rich_log["blockNumber"] == txn_receipt["blockNumber"]
     assert rich_log["transactionIndex"] == txn_receipt["transactionIndex"]
@@ -880,9 +878,8 @@ def test_event_rich_log_with_byte_args(
         "arg1": [b"54"],
     }
     assert rich_log["args"] == expected_args
-    assert rich_log.args == expected_args
     for arg in expected_args:
-        assert getattr(rich_log.args, arg) == expected_args[arg]
+        assert rich_log["args"][arg] == expected_args[arg]
     assert rich_log["blockHash"] == txn_receipt["blockHash"]
     assert rich_log["blockNumber"] == txn_receipt["blockNumber"]
     assert rich_log["transactionIndex"] == txn_receipt["transactionIndex"]
@@ -976,12 +973,12 @@ def test_get_all_entries_with_nested_tuple_event(w3, emitter):
 
     log_entry = entries[0]
 
-    assert log_entry.args == {"arg0": 1, "arg1": (2, 3, (4,))}
-    assert log_entry.event == "LogStructArgs"
-    assert log_entry.blockHash == txn_receipt["blockHash"]
-    assert log_entry.blockNumber == txn_receipt["blockNumber"]
-    assert log_entry.transactionIndex == txn_receipt["transactionIndex"]
-    assert is_same_address(log_entry.address, emitter.address)
+    assert log_entry["args"] == {"arg0": 1, "arg1": (2, 3, (4,))}
+    assert log_entry["event"] == "LogStructArgs"
+    assert log_entry["blockHash"] == txn_receipt["blockHash"]
+    assert log_entry["blockNumber"] == txn_receipt["blockNumber"]
+    assert log_entry["transactionIndex"] == txn_receipt["transactionIndex"]
+    assert is_same_address(log_entry["address"], emitter.address)
 
 
 def test_get_all_entries_with_nested_tuple_event_non_strict(
@@ -1002,9 +999,9 @@ def test_get_all_entries_with_nested_tuple_event_non_strict(
 
     log_entry = entries[0]
 
-    assert log_entry.args == {"arg0": 1, "arg1": (2, 3, (4,))}
-    assert log_entry.event == "LogStructArgs"
-    assert log_entry.blockHash == txn_receipt["blockHash"]
-    assert log_entry.blockNumber == txn_receipt["blockNumber"]
-    assert log_entry.transactionIndex == txn_receipt["transactionIndex"]
-    assert is_same_address(log_entry.address, non_strict_emitter.address)
+    assert log_entry["args"] == {"arg0": 1, "arg1": (2, 3, (4,))}
+    assert log_entry["event"] == "LogStructArgs"
+    assert log_entry["blockHash"] == txn_receipt["blockHash"]
+    assert log_entry["blockNumber"] == txn_receipt["blockNumber"]
+    assert log_entry["transactionIndex"] == txn_receipt["transactionIndex"]
+    assert is_same_address(log_entry["address"], non_strict_emitter.address)

web3/_utils/events.py

@@ -208,7 +208,10 @@ def get_event_abi_types_for_decoding(
 
 @curry
 def get_event_data(
-    abi_codec: ABICodec, event_abi: ABIEvent, log_entry: LogReceipt
+    abi_codec: ABICodec,
+    event_abi: ABIEvent,
+    log_entry: LogReceipt,
+    use_attribute_dicts: bool = False,
 ) -> EventData:
     """
     Given an event ABI and a log entry for that event, return the decoded
@@ -269,18 +272,21 @@ def get_event_data(
         )
     )
 
-    event_data = {
-        "args": event_args,
-        "event": event_abi["name"],
-        "logIndex": log_entry["logIndex"],
-        "transactionIndex": log_entry["transactionIndex"],
-        "transactionHash": log_entry["transactionHash"],
-        "address": log_entry["address"],
-        "blockHash": log_entry["blockHash"],
-        "blockNumber": log_entry["blockNumber"],
-    }
+    event_data = EventData(
+        args=event_args,
+        event=event_abi["name"],
+        logIndex=log_entry["logIndex"],
+        transactionIndex=log_entry["transactionIndex"],
+        transactionHash=log_entry["transactionHash"],
+        address=log_entry["address"],
+        blockHash=log_entry["blockHash"],
+        blockNumber=log_entry["blockNumber"],
+    )
+
+    if use_attribute_dicts:
+        return cast(EventData, AttributeDict.recursive(event_data))
 
-    return cast(EventData, AttributeDict.recursive(event_data))
+    return event_data
 
 
 @to_tuple

web3/_utils/method_formatters.py

@@ -32,7 +32,6 @@
     is_0x_prefixed,
     is_address,
     is_bytes,
-    is_dict,
     is_integer,
     is_null,
     is_string,
@@ -88,6 +87,7 @@
 )
 from web3.datastructures import (
     AttributeDict,
+    ReadableAttributeDict,
 )
 from web3.exceptions import (
     BlockNotFound,
@@ -155,6 +155,19 @@ def is_attrdict(val: Any) -> bool:
 not_attrdict = complement(is_attrdict)
 
 
+@curry
+def type_aware_apply_formatters_to_dict(
+    formatters: Formatters,
+    value: Union[AttributeDict[str, Any], Dict[str, Any]],
+) -> Union[ReadableAttributeDict[str, Any], Dict[str, Any]]:
+    formatted_dict: Dict[str, Any] = apply_formatters_to_dict(formatters, dict(value))
+    return (
+        AttributeDict.recursive(formatted_dict)
+        if is_attrdict(value)
+        else formatted_dict
+    )
+
+
 TRANSACTION_RESULT_FORMATTERS = {
     "blockHash": apply_formatter_if(is_not_null, to_hexbytes(32)),
     "blockNumber": apply_formatter_if(is_not_null, to_integer_if_hex),
@@ -179,7 +192,9 @@ def is_attrdict(val: Any) -> bool:
 }
 
 
-transaction_result_formatter = apply_formatters_to_dict(TRANSACTION_RESULT_FORMATTERS)
+transaction_result_formatter = type_aware_apply_formatters_to_dict(
+    TRANSACTION_RESULT_FORMATTERS
+)
 
 
 def apply_list_to_array_formatter(formatter: Any) -> Callable[..., Any]:
@@ -198,7 +213,7 @@ def apply_list_to_array_formatter(formatter: Any) -> Callable[..., Any]:
 }
 
 
-log_entry_formatter = apply_formatters_to_dict(LOG_ENTRY_FORMATTERS)
+log_entry_formatter = type_aware_apply_formatters_to_dict(LOG_ENTRY_FORMATTERS)
 
 
 RECEIPT_FORMATTERS = {
@@ -219,7 +234,7 @@ def apply_list_to_array_formatter(formatter: Any) -> Callable[..., Any]:
 }
 
 
-receipt_formatter = apply_formatters_to_dict(RECEIPT_FORMATTERS)
+receipt_formatter = type_aware_apply_formatters_to_dict(RECEIPT_FORMATTERS)
 
 BLOCK_FORMATTERS = {
     "baseFeePerGas": to_integer_if_hex,
@@ -256,7 +271,7 @@ def apply_list_to_array_formatter(formatter: Any) -> Callable[..., Any]:
 }
 
 
-block_formatter = apply_formatters_to_dict(BLOCK_FORMATTERS)
+block_formatter = type_aware_apply_formatters_to_dict(BLOCK_FORMATTERS)
 
 
 SYNCING_FORMATTERS = {
@@ -268,7 +283,7 @@ def apply_list_to_array_formatter(formatter: Any) -> Callable[..., Any]:
 }
 
 
-syncing_formatter = apply_formatters_to_dict(SYNCING_FORMATTERS)
+syncing_formatter = type_aware_apply_formatters_to_dict(SYNCING_FORMATTERS)
 
 
 TRANSACTION_POOL_CONTENT_FORMATTERS = {
@@ -283,7 +298,7 @@ def apply_list_to_array_formatter(formatter: Any) -> Callable[..., Any]:
 }
 
 
-transaction_pool_content_formatter = apply_formatters_to_dict(
+transaction_pool_content_formatter = type_aware_apply_formatters_to_dict(
     TRANSACTION_POOL_CONTENT_FORMATTERS
 )
 
@@ -294,7 +309,7 @@ def apply_list_to_array_formatter(formatter: Any) -> Callable[..., Any]:
 }
 
 
-transaction_pool_inspect_formatter = apply_formatters_to_dict(
+transaction_pool_inspect_formatter = type_aware_apply_formatters_to_dict(
     TRANSACTION_POOL_INSPECT_FORMATTERS
 )
 
@@ -308,7 +323,7 @@ def apply_list_to_array_formatter(formatter: Any) -> Callable[..., Any]:
     ),
 }
 
-fee_history_formatter = apply_formatters_to_dict(FEE_HISTORY_FORMATTERS)
+fee_history_formatter = type_aware_apply_formatters_to_dict(FEE_HISTORY_FORMATTERS)
 
 STORAGE_PROOF_FORMATTERS = {
     "key": HexBytes,
@@ -324,19 +339,19 @@ def apply_list_to_array_formatter(formatter: Any) -> Callable[..., Any]:
     "nonce": to_integer_if_hex,
     "storageHash": to_hexbytes(32),
     "storageProof": apply_list_to_array_formatter(
-        apply_formatters_to_dict(STORAGE_PROOF_FORMATTERS)
+        type_aware_apply_formatters_to_dict(STORAGE_PROOF_FORMATTERS)
     ),
 }
 
-proof_formatter = apply_formatters_to_dict(ACCOUNT_PROOF_FORMATTERS)
+proof_formatter = type_aware_apply_formatters_to_dict(ACCOUNT_PROOF_FORMATTERS)
 
 FILTER_PARAMS_FORMATTERS = {
     "fromBlock": apply_formatter_if(is_integer, integer_to_hex),
     "toBlock": apply_formatter_if(is_integer, integer_to_hex),
 }
 
 
-filter_params_formatter = apply_formatters_to_dict(FILTER_PARAMS_FORMATTERS)
+filter_params_formatter = type_aware_apply_formatters_to_dict(FILTER_PARAMS_FORMATTERS)
 
 
 filter_result_formatter = apply_one_of_formatters(
@@ -351,7 +366,9 @@ def apply_list_to_array_formatter(formatter: Any) -> Callable[..., Any]:
     "maxPriorityFeePerGas": to_hex_if_integer,
 }
 
-transaction_request_formatter = apply_formatters_to_dict(TRANSACTION_REQUEST_FORMATTERS)
+transaction_request_formatter = type_aware_apply_formatters_to_dict(
+    TRANSACTION_REQUEST_FORMATTERS
+)
 transaction_param_formatter = compose(
     remove_key_if("to", lambda txn: txn["to"] in {"", b"", None}),
     remove_key_if("gasPrice", lambda txn: txn["gasPrice"] in {"", b"", None}),
@@ -398,22 +415,22 @@ def apply_list_to_array_formatter(formatter: Any) -> Callable[..., Any]:
     "tx": transaction_result_formatter,
 }
 
-signed_tx_formatter = apply_formatters_to_dict(SIGNED_TX_FORMATTER)
+signed_tx_formatter = type_aware_apply_formatters_to_dict(SIGNED_TX_FORMATTER)
 
-FILTER_PARAM_NORMALIZERS = apply_formatters_to_dict(
+FILTER_PARAM_NORMALIZERS = type_aware_apply_formatters_to_dict(
     {"address": apply_formatter_if(is_string, lambda x: [x])}
 )
 
 
 GETH_WALLET_FORMATTER = {"address": to_checksum_address}
 
-geth_wallet_formatter = apply_formatters_to_dict(GETH_WALLET_FORMATTER)
+geth_wallet_formatter = type_aware_apply_formatters_to_dict(GETH_WALLET_FORMATTER)
 
 GETH_WALLETS_FORMATTER = {
     "accounts": apply_list_to_array_formatter(geth_wallet_formatter),
 }
 
-geth_wallets_formatter = apply_formatters_to_dict(GETH_WALLETS_FORMATTER)
+geth_wallets_formatter = type_aware_apply_formatters_to_dict(GETH_WALLETS_FORMATTER)
 
 
 PYTHONIC_REQUEST_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
@@ -556,10 +573,6 @@ def apply_list_to_array_formatter(formatter: Any) -> Callable[..., Any]:
     RPC.net_peerCount: to_integer_if_hex,
 }
 
-ATTRDICT_FORMATTER = {
-    "*": apply_formatter_if(is_dict and not_attrdict, AttributeDict.recursive)
-}
-
 METHOD_NORMALIZERS: Dict[RPCEndpoint, Callable[..., Any]] = {
     RPC.eth_getLogs: apply_formatter_at_index(FILTER_PARAM_NORMALIZERS, 0),
     RPC.eth_newFilter: apply_formatter_at_index(FILTER_PARAM_NORMALIZERS, 0),
@@ -820,10 +833,7 @@ def get_result_formatters(
     partial_formatters = apply_module_to_formatters(
         formatters_requiring_module, module, method_name
     )
-    attrdict_formatter = apply_formatter_if(
-        is_dict and not_attrdict, AttributeDict.recursive
-    )
-    return compose(*partial_formatters, attrdict_formatter, *formatters)
+    return compose(*partial_formatters, *formatters)
 
 
 def get_error_formatters(

web3/contract/async_contract.py

@@ -38,6 +38,9 @@
 from web3._utils.filters import (
     AsyncLogFilter,
 )
+from web3._utils.method_formatters import (
+    is_attrdict,
+)
 from web3._utils.normalizers import (
     normalize_abi,
     normalize_address_no_ens,
@@ -414,8 +417,14 @@ async def get_logs(
         )
 
         # Convert raw binary data to Python proxy objects as described by ABI
-        return tuple(
-            get_event_data(self.w3.codec, abi, entry) for entry in logs  # type: ignore
+        return tuple(  # type: ignore
+            get_event_data(
+                self.w3.codec,
+                abi,
+                entry,
+                use_attribute_dicts=is_attrdict(entry),
+            )
+            for entry in logs
         )
 
     @combomethod

web3/contract/contract.py

@@ -34,6 +34,9 @@
 from web3._utils.filters import (
     LogFilter,
 )
+from web3._utils.method_formatters import (
+    is_attrdict,
+)
 from web3._utils.normalizers import (
     normalize_abi,
     normalize_address,
@@ -162,7 +165,15 @@ def get_logs(
         )
 
         # Convert raw binary data to Python proxy objects as described by ABI
-        return tuple(get_event_data(self.w3.codec, abi, entry) for entry in logs)
+        return tuple(
+            get_event_data(
+                self.w3.codec,
+                abi,
+                entry,
+                use_attribute_dicts=is_attrdict(entry),
+            )
+            for entry in logs
+        )
 
     @combomethod
     def create_filter(

web3/datastructures.py

@@ -79,8 +79,8 @@ def _apply_if_mapping(cls: Type[T], value: TValue) -> Union[T, TValue]:
         if isinstance(value, Mapping):
             # error: Too many arguments for "object"
             return cls(value)  # type: ignore
-        else:
-            return value
+
+        return value
 
     @classmethod
     def recursive(cls, value: TValue) -> "ReadableAttributeDict[TKey, TValue]":