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

newsfragments/2805.breaking.rst

@@ -0,0 +1 @@
+``dict`` to ``AttributeDict`` conversion is no longer a default result formatter. This conversion is now done via a default middleware that may be removed.

web3/_utils/events.py

@@ -208,7 +208,9 @@ 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,
 ) -> EventData:
     """
     Given an event ABI and a log entry for that event, return the decoded
@@ -269,18 +271,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 isinstance(log_entry, AttributeDict):
+        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

@@ -414,8 +414,8 @@ 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) for entry in logs
         )
 
     @combomethod

web3/manager.py

@@ -40,6 +40,7 @@
 )
 from web3.middleware import (
     abi_middleware,
+    async_attrdict_middleware,
     async_buffered_gas_estimate_middleware,
     async_gas_price_strategy_middleware,
     async_validation_middleware,
@@ -115,7 +116,7 @@ def __init__(
 
         if middlewares is None:
             middlewares = (
-                self.async_default_middlewares(w3)
+                self.async_default_middlewares()
                 if self.provider.is_async
                 else self.default_middlewares(w3)
             )
@@ -143,20 +144,21 @@ def default_middlewares(w3: "Web3") -> List[Tuple[Middleware, str]]:
             (request_parameter_normalizer, "request_param_normalizer"),  # Delete
             (gas_price_strategy_middleware, "gas_price_strategy"),
             (name_to_address_middleware(w3), "name_to_address"),  # Add Async
-            (attrdict_middleware, "attrdict"),  # Delete
+            (attrdict_middleware, "attrdict"),
             (pythonic_middleware, "pythonic"),  # Delete
             (validation_middleware, "validation"),
             (abi_middleware, "abi"),  # Delete
             (buffered_gas_estimate_middleware, "gas_estimate"),
         ]
 
     @staticmethod
-    def async_default_middlewares(w3: "Web3") -> List[Tuple[Middleware, str]]:
+    def async_default_middlewares() -> List[Tuple[Middleware, str]]:
         """
         List the default async middlewares for the request manager.
         """
         return [
             (async_gas_price_strategy_middleware, "gas_price_strategy"),
+            (async_attrdict_middleware, "attrdict"),
             (async_validation_middleware, "validation"),
             (async_buffered_gas_estimate_middleware, "gas_estimate"),
         ]

web3/middleware/__init__.py

@@ -6,9 +6,6 @@
     Sequence,
 )
 
-from web3.middleware.async_cache import (  # noqa: F401
-    _async_simple_cache_middleware as async_simple_cache_middleware,
-)
 from web3.types import (
     Middleware,
     RPCEndpoint,
@@ -18,7 +15,11 @@
 from .abi import (  # noqa: F401
     abi_middleware,
 )
+from .async_cache import (  # noqa: F401
+    _async_simple_cache_middleware as async_simple_cache_middleware,
+)
 from .attrdict import (  # noqa: F401
+    async_attrdict_middleware,
     attrdict_middleware,
 )
 from .buffered_gas_estimate import (  # noqa: F401

web3/middleware/attrdict.py

@@ -4,9 +4,6 @@
     Callable,
 )
 
-from eth_utils import (
-    is_dict,
-)
 from eth_utils.toolz import (
     assoc,
 )
@@ -15,6 +12,7 @@
     AttributeDict,
 )
 from web3.types import (
+    AsyncMiddleware,
     RPCEndpoint,
     RPCResponse,
 )
@@ -24,21 +22,48 @@
 
 
 def attrdict_middleware(
-    make_request: Callable[[RPCEndpoint, Any], Any], w3: "Web3"
+    make_request: Callable[[RPCEndpoint, Any], Any], _w3: "Web3"
 ) -> Callable[[RPCEndpoint, Any], RPCResponse]:
     """
-    Converts any result which is a dictionary into an a
+    Converts any result which is a dictionary into an `AttributeDict`.
+
+    Note: Accessing `AttributeDict` properties via attribute
+        (e.g. my_attribute_dict.property1) will not preserve typing.
     """
 
     def middleware(method: RPCEndpoint, params: Any) -> RPCResponse:
         response = make_request(method, params)
 
         if "result" in response:
-            result = response["result"]
-            if is_dict(result) and not isinstance(result, AttributeDict):
-                return assoc(response, "result", AttributeDict.recursive(result))
-            else:
-                return response
+            return assoc(
+                response, "result", AttributeDict.recursive(response["result"])
+            )
+        else:
+            return response
+
+    return middleware
+
+
+# --- async --- #
+
+
+async def async_attrdict_middleware(
+    make_request: Callable[[RPCEndpoint, Any], Any], _async_w3: "Web3"
+) -> AsyncMiddleware:
+    """
+    Converts any result which is a dictionary into an `AttributeDict`.
+
+    Note: Accessing `AttributeDict` properties via attribute
+        (e.g. my_attribute_dict.property1) will not preserve typing.
+    """
+
+    async def middleware(method: RPCEndpoint, params: Any) -> RPCResponse:
+        response = await make_request(method, params)
+
+        if "result" in response:
+            return assoc(
+                response, "result", AttributeDict.recursive(response["result"])
+            )
         else:
             return response