ignore no-untyped-call errors, all are from eth-abi and can be removed once it has better typing

Author: pacrob

pyproject.toml

@@ -21,7 +21,7 @@ check_untyped_defs = true
 disallow_any_generics = true
 disallow_incomplete_defs = true
 disallow_subclassing_any = true
-disallow_untyped_calls = false
+disallow_untyped_calls = true
 disallow_untyped_decorators = false
 disallow_untyped_defs = true
 ignore_missing_imports = true

web3/_utils/abi.py

@@ -153,7 +153,7 @@ def validate_value(cls, value: Any) -> None:
         if is_ens_name(value):
             return
 
-        super().validate_value(value)
+        super().validate_value(value)  # type: ignore[no-untyped-call]
 
 
 class AcceptsHexStrEncoder(encoding.BaseEncoder):
@@ -168,7 +168,7 @@ def __init__(
         subencoder: encoding.BaseEncoder,
         **kwargs: Dict[str, Any],
     ) -> None:
-        super().__init__(**kwargs)
+        super().__init__(**kwargs)  # type: ignore[no-untyped-call]
         self.subencoder = subencoder
         self.is_dynamic = subencoder.is_dynamic
 
@@ -180,7 +180,7 @@ def from_type_str(
         # cast b/c expects BaseCoder but `from_type_string`
         # restricted to BaseEncoder subclasses
         subencoder = cast(
-            encoding.BaseEncoder, subencoder_cls.from_type_str(abi_type, registry)
+            encoding.BaseEncoder, subencoder_cls.from_type_str(abi_type, registry)  # type: ignore[no-untyped-call]  # noqa: E501
         )
         return cls(subencoder)
 
@@ -245,7 +245,7 @@ class ExactLengthBytesEncoder(BytesEncoder):
     is_strict = True
 
     def validate(self) -> None:
-        super().validate()
+        super().validate()  # type: ignore[no-untyped-call]
         if self.value_bit_size is None:
             raise Web3ValueError("`value_bit_size` may not be none")
         if self.data_byte_size is None:
@@ -262,12 +262,12 @@ def validate(self) -> None:
         if self.value_bit_size > self.data_byte_size * 8:
             raise Web3ValueError("Value byte size exceeds data size")
 
-    @parse_type_str("bytes")
+    @parse_type_str("bytes")  # type: ignore[no-untyped-call]
     def from_type_str(
         cls, abi_type: BasicType, registry: ABIRegistry
     ) -> "ExactLengthBytesEncoder":
         subencoder_cls = cls.get_subencoder_class()
-        subencoder = subencoder_cls.from_type_str(abi_type.to_type_str(), registry)
+        subencoder = subencoder_cls.from_type_str(abi_type.to_type_str(), registry)  # type: ignore[no-untyped-call]  # noqa: E501
         return cast(
             ExactLengthBytesEncoder,
             # type ignored b/c mypy thinks the __call__ is from BaseEncoder, but it's
@@ -303,7 +303,7 @@ def validate_value(cls, value: Any) -> None:
                     msg="not decodable as unicode string",
                 )
 
-        super().validate_value(value)
+        super().validate_value(value)  # type: ignore[no-untyped-call]
 
 
 TUPLE_TYPE_STR_RE = re.compile(r"^(tuple)((\[([1-9]\d*\b)?])*)??$")
@@ -676,33 +676,33 @@ def strip_abi_type(elements: Any) -> Any:
 def build_non_strict_registry() -> ABIRegistry:
     # We make a copy here just to make sure that eth-abi's default registry is not
     # affected by our custom encoder subclasses
-    registry = default_registry.copy()
+    registry = default_registry.copy()  # type: ignore[no-untyped-call]
 
     registry.unregister("address")
     registry.unregister("bytes<M>")
     registry.unregister("bytes")
     registry.unregister("string")
 
     registry.register(
-        BaseEquals("address"),
+        BaseEquals("address"),  # type: ignore[no-untyped-call]
         AddressEncoder,
         decoding.AddressDecoder,
         label="address",
     )
     registry.register(
-        BaseEquals("bytes", with_sub=True),
+        BaseEquals("bytes", with_sub=True),  # type: ignore[no-untyped-call]
         BytesEncoder,
         decoding.BytesDecoder,
         label="bytes<M>",
     )
     registry.register(
-        BaseEquals("bytes", with_sub=False),
+        BaseEquals("bytes", with_sub=False),  # type: ignore[no-untyped-call]
         ByteStringEncoder,
         decoding.ByteStringDecoder,
         label="bytes",
     )
     registry.register(
-        BaseEquals("string"),
+        BaseEquals("string"),  # type: ignore[no-untyped-call]
         TextStringEncoder,
         decoding.StringDecoder,
         label="string",
@@ -711,33 +711,33 @@ def build_non_strict_registry() -> ABIRegistry:
 
 
 def build_strict_registry() -> ABIRegistry:
-    registry = default_registry.copy()
+    registry = default_registry.copy()  # type: ignore[no-untyped-call]
 
     registry.unregister("address")
     registry.unregister("bytes<M>")
     registry.unregister("bytes")
     registry.unregister("string")
 
     registry.register(
-        BaseEquals("address"),
+        BaseEquals("address"),  # type: ignore[no-untyped-call]
         AddressEncoder,
         decoding.AddressDecoder,
         label="address",
     )
     registry.register(
-        BaseEquals("bytes", with_sub=True),
+        BaseEquals("bytes", with_sub=True),  # type: ignore[no-untyped-call]
         ExactLengthBytesEncoder,
         decoding.BytesDecoder,
         label="bytes<M>",
     )
     registry.register(
-        BaseEquals("bytes", with_sub=False),
+        BaseEquals("bytes", with_sub=False),  # type: ignore[no-untyped-call]
         StrictByteStringEncoder,
         decoding.ByteStringDecoder,
         label="bytes",
     )
     registry.register(
-        BaseEquals("string"),
+        BaseEquals("string"),  # type: ignore[no-untyped-call]
         encoding.TextStringEncoder,
         decoding.StringDecoder,
         label="string",

web3/_utils/encoding.py

@@ -259,7 +259,7 @@ class DynamicArrayPackedEncoder(BaseArrayEncoder):
     is_dynamic = True
 
     def encode(self, value: Sequence[Any]) -> bytes:
-        encoded_elements = self.encode_elements(value)
+        encoded_elements = self.encode_elements(value)  # type: ignore[no-untyped-call]
         encoded_value = encoded_elements
 
         return encoded_value
@@ -278,10 +278,10 @@ def encode_single_packed(_type: TypeStr, value: Any) -> bytes:
     )
 
     abi_type = abi_type_parser.parse(_type)
-    if has_arrlist(_type):
+    if has_arrlist(_type):  # type: ignore[no-untyped-call]
         item_encoder = registry.get_encoder(abi_type.item_type.to_type_str())
         if abi_type.arrlist[-1] != 1:
-            return DynamicArrayPackedEncoder(item_encoder=item_encoder).encode(value)
+            return DynamicArrayPackedEncoder(item_encoder=item_encoder).encode(value)  # type: ignore[no-untyped-call]  # noqa: E501
         else:
             raise NotImplementedError(
                 "Fixed arrays are not implemented in this packed encoder prototype"

web3/middleware/signing.py

@@ -218,10 +218,12 @@ async def async_request_processor(self, method: "RPCEndpoint", params: Any) -> A
                 account = self._accounts[to_checksum_address(tx_from)]
                 EthAccountTxParams: TypeAlias = Dict[
                     str,
-                    Sequence[Dict[str, HexStr | Sequence[HexStr]]]
-                    | bytes
-                    | HexStr
-                    | int,
+                    Union[
+                        Sequence[Dict[str, Union[HexStr, Sequence[HexStr]]]],
+                        bytes,
+                        HexStr,
+                        int,
+                    ],
                 ]
                 raw_tx = account.sign_transaction(
                     cast(EthAccountTxParams, filled_transaction)