remove unused type:ignores, bump requests to >=2.23 where it first supports py38, add types-requests to install_requires, clear mypy errors

pacrob · pacrob · commit 97c4f995e038 · 2024-08-01T10:34:40.000-06:00
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
@@ -47,7 +47,6 @@ repos:
     hooks:
     -   id: mypy-local
         name: run mypy with all dev dependencies present
-        # exclude: 'tests/|conftest.py'
         entry: python -m mypy -p web3
         language: system
         always_run: true
diff --git a/ens/async_ens.py b/ens/async_ens.py
@@ -4,6 +4,7 @@
 from typing import (
     TYPE_CHECKING,
     Any,
+    Coroutine,
     Optional,
     Sequence,
     Tuple,
@@ -469,9 +470,13 @@ async def _set_resolver(
             resolver_addr = await self.address("resolver.eth")
         namehash = raw_name_to_hash(name)
         if await self.ens.caller.resolver(namehash) != resolver_addr:
-            await self.ens.functions.setResolver(namehash, resolver_addr).transact(
-                transact
+            coro = cast(
+                Coroutine[Any, Any, HexBytes],
+                self.ens.functions.setResolver(namehash, resolver_addr).transact(
+                    transact
+                ),
             )
+            await coro
         return cast("AsyncContract", self._resolver_contract(address=resolver_addr))
 
     async def _resolve(
@@ -553,11 +558,15 @@ async def _claim_ownership(
         transact = deepcopy(transact)
         transact["from"] = old_owner or owner
         for label in reversed(unowned):
-            await self.ens.functions.setSubnodeOwner(
-                raw_name_to_hash(owned),
-                label_to_hash(label),
-                owner,
-            ).transact(transact)
+            coro = cast(
+                Coroutine[Any, Any, HexBytes],
+                self.ens.functions.setSubnodeOwner(
+                    raw_name_to_hash(owned),
+                    label_to_hash(label),
+                    owner,
+                ).transact(transact),
+            )
+            await coro
             owned = f"{label}.{owned}"
 
     async def _setup_reverse(
diff --git a/ens/exceptions.py b/ens/exceptions.py
@@ -29,8 +29,7 @@ class AddressMismatch(ENSException):
     """
 
 
-# type ignored because subclassing IDNAError which has type Any
-class InvalidName(idna.IDNAError, ENSException):  # type: ignore[misc]
+class InvalidName(idna.IDNAError, ENSException):
     """
     Raised if the provided name does not meet the normalization
     standards specified in `ENSIP-15
diff --git a/pyproject.toml b/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 = true
+disallow_untyped_calls = false
 disallow_untyped_decorators = false
 disallow_untyped_defs = true
 ignore_missing_imports = true
@@ -32,7 +32,6 @@ warn_return_any = false
 warn_unused_configs = true
 warn_unused_ignores = true
 
-
 [tool.pydocstyle]
 # All error codes found here:
 # http://www.pydocstyle.org/en/3.0.0/error_codes.html
diff --git a/setup.py b/setup.py
@@ -70,8 +70,9 @@
         "hexbytes>=1.2.0",
         "pydantic>=2.4.0",
         "pywin32>=223;platform_system=='Windows'",
-        "requests>=2.16.0",
+        "requests>=2.23.0",
         "typing-extensions>=4.0.1",
+        "types-requests>=2.0.0",
         "websockets>=10.0.0",
         "pyunormalize>=15.0.0",
     ],
diff --git a/tox.ini b/tox.ini
@@ -54,6 +54,7 @@ basepython =
 
 [testenv:py{38,39,310,311,312}-lint]
 deps=pre-commit
+extras=dev
 commands=
     pre-commit install
     pre-commit run --all-files --show-diff-on-failure
diff --git a/web3/_utils/abi.py b/web3/_utils/abi.py
@@ -147,8 +147,7 @@ def filter_by_argument_name(
     return abis_with_matching_args
 
 
-# type ignored because subclassing encoding.AddressEncoder which has type Any
-class AddressEncoder(encoding.AddressEncoder):  # type: ignore[misc]
+class AddressEncoder(encoding.AddressEncoder):
     @classmethod
     def validate_value(cls, value: Any) -> None:
         if is_ens_name(value):
@@ -157,8 +156,7 @@ def validate_value(cls, value: Any) -> None:
         super().validate_value(value)
 
 
-# type ignored because subclassing encoding.BytesEncoder which has type Any
-class AcceptsHexStrEncoder(encoding.BaseEncoder):  # type: ignore[misc]
+class AcceptsHexStrEncoder(encoding.BaseEncoder):
     subencoder_cls: Type[encoding.BaseEncoder] = None
     is_strict: bool = None
     is_big_endian: bool = False
@@ -270,10 +268,16 @@ def from_type_str(
     ) -> "ExactLengthBytesEncoder":
         subencoder_cls = cls.get_subencoder_class()
         subencoder = subencoder_cls.from_type_str(abi_type.to_type_str(), registry)
-        return cls(
-            subencoder,
-            value_bit_size=abi_type.sub * 8,
-            data_byte_size=abi_type.sub,
+        return cast(
+            ExactLengthBytesEncoder,
+            # type ignored b/c mypy thinks the __call__ is from BaseEncoder, but it's
+            # from ExactLengthBytesEncoder, which does have value_bit_size and
+            # data_byte_size attributes
+            cls(  # type: ignore[call-arg]
+                subencoder,
+                value_bit_size=abi_type.sub * 8,
+                data_byte_size=abi_type.sub,
+            ),
         )
 
 
@@ -287,8 +291,7 @@ class StrictByteStringEncoder(AcceptsHexStrEncoder):
     is_strict = True
 
 
-# type ignored because subclassing encoding.TextStringEncoder which has type Any
-class TextStringEncoder(encoding.TextStringEncoder):  # type: ignore[misc]
+class TextStringEncoder(encoding.TextStringEncoder):
     @classmethod
     def validate_value(cls, value: Any) -> None:
         if is_bytes(value):
diff --git a/web3/_utils/compat/__init__.py b/web3/_utils/compat/__init__.py
@@ -12,4 +12,5 @@
     NotRequired,  # py311
     Self,  # py311
     Unpack,  # py311
+    TypeAlias,  # py310
 )
diff --git a/web3/_utils/encoding.py b/web3/_utils/encoding.py
@@ -255,8 +255,7 @@ def to_4byte_hex(hex_or_str_or_bytes: Union[HexStr, str, bytes, int]) -> HexStr:
     return pad_hex(hex_str, size_of_4bytes)
 
 
-# type ignored because subclassing BaseArrayEncoder which has type Any
-class DynamicArrayPackedEncoder(BaseArrayEncoder):  # type: ignore[misc]
+class DynamicArrayPackedEncoder(BaseArrayEncoder):
     is_dynamic = True
 
     def encode(self, value: Sequence[Any]) -> bytes:
diff --git a/web3/_utils/events.py b/web3/_utils/events.py
@@ -134,7 +134,7 @@ def construct_event_topic_set(
         for key, value in arguments.items()  # type: ignore
     }
 
-    event_topic = encode_hex(event_abi_to_log_topic(event_abi))
+    event_topic = encode_hex(event_abi_to_log_topic(cast(Dict[str, Any], event_abi)))
     indexed_args = get_indexed_event_inputs(event_abi)
     zipped_abi_and_args = [
         (arg, normalized_args.get(arg["name"], [None])) for arg in indexed_args
@@ -459,8 +459,8 @@ async def deploy(self, async_w3: "AsyncWeb3") -> "AsyncLogFilter":
         if not isinstance(async_w3, web3.AsyncWeb3):
             raise Web3ValueError(f"Invalid web3 argument: got: {async_w3!r}")
 
-        for arg in AttributeDict.values(self.args):
-            arg._immutable = True  # type: ignore[attr-defined]
+        for arg in self.args.values():
+            arg._immutable = True
         self._immutable = True
 
         log_filter = await async_w3.eth.filter(self.filter_params)
@@ -475,7 +475,7 @@ async def deploy(self, async_w3: "AsyncWeb3") -> "AsyncLogFilter":
 
 def initialize_event_topics(event_abi: ABIEvent) -> Union[bytes, List[Any]]:
     if event_abi["anonymous"] is False:
-        return event_abi_to_log_topic(event_abi)
+        return event_abi_to_log_topic(cast(Dict[str, Any], event_abi))
     else:
         return list()
 
diff --git a/web3/_utils/fee_utils.py b/web3/_utils/fee_utils.py
@@ -45,13 +45,13 @@ def fee_history_priority_fee(eth: "Eth") -> Wei:
     # This is a tested internal call so no need for type hinting. We can keep
     # better consistency between the sync and async calls by unpacking
     # PRIORITY_FEE_HISTORY_PARAMS as constants here.
-    fee_history = eth.fee_history(*PRIORITY_FEE_HISTORY_PARAMS)
+    fee_history = eth.fee_history(*PRIORITY_FEE_HISTORY_PARAMS)  # type: ignore
     return _fee_history_priority_fee_estimate(fee_history)
 
 
 async def async_fee_history_priority_fee(async_eth: "AsyncEth") -> Wei:
     # This is a tested internal call so no need for type hinting. We can keep
     # better consistency between the sync and async calls by unpacking
     # PRIORITY_FEE_HISTORY_PARAMS as constants here.
-    fee_history = await async_eth.fee_history(*PRIORITY_FEE_HISTORY_PARAMS)
+    fee_history = await async_eth.fee_history(*PRIORITY_FEE_HISTORY_PARAMS)  # type: ignore  # noqa: E501
     return _fee_history_priority_fee_estimate(fee_history)
diff --git a/web3/_utils/filters.py b/web3/_utils/filters.py
@@ -10,6 +10,7 @@
     Sequence,
     Tuple,
     Union,
+    cast,
 )
 
 from eth_abi.codec import (
@@ -78,9 +79,9 @@ def construct_event_filter_params(
     address: Optional[ChecksumAddress] = None,
 ) -> Tuple[List[List[Optional[HexStr]]], FilterParams]:
     filter_params: FilterParams = {}
-    topic_set: Sequence[HexStr] = construct_event_topic_set(
-        event_abi, abi_codec, argument_filters
-    )
+    topic_set: Union[
+        Sequence[HexStr], Sequence[Sequence[HexStr]]
+    ] = construct_event_topic_set(event_abi, abi_codec, argument_filters)
 
     if topics is not None:
         if len(topic_set) > 1:
@@ -91,7 +92,7 @@ def construct_event_filter_params(
         topic_set = topics
 
     if len(topic_set) == 1 and is_list_like(topic_set[0]):
-        filter_params["topics"] = topic_set[0]
+        filter_params["topics"] = cast(Sequence[HexStr], topic_set[0])
     else:
         filter_params["topics"] = topic_set
 
diff --git a/web3/_utils/method_formatters.py b/web3/_utils/method_formatters.py
@@ -199,7 +199,7 @@ def storage_key_to_hexstr(value: Union[bytes, int, str]) -> HexStr:
             return HexStr(f"0x{value}")
     elif isinstance(value, bytes):
         if len(value) == 32:
-            return HexBytes(value).to_0x_hex()
+            return cast(HexStr, HexBytes(value).to_0x_hex())
     elif isinstance(value, int):
         return storage_key_to_hexstr(hex(value))
     raise Web3ValueError(f"Storage key must be a 32-byte value, got {value!r}")
@@ -424,8 +424,8 @@ def storage_key_to_hexstr(value: Union[bytes, int, str]) -> HexStr:
 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),
+    "fromBlock": to_hex_if_integer,
+    "toBlock": to_hex_if_integer,
 }
 
 
diff --git a/web3/_utils/module_testing/eth_module.py b/web3/_utils/module_testing/eth_module.py
@@ -1149,7 +1149,8 @@ async def test_eth_get_raw_transaction_by_block_raises_error_block_identifier(
                 f"{unknown_identifier}"
             ),
         ):
-            await async_w3.eth.get_raw_transaction_by_block(unknown_identifier, 0)
+            # type ignored because we are testing an invalid block identifier
+            await async_w3.eth.get_raw_transaction_by_block(unknown_identifier, 0)  # type: ignore  # noqa: E501
 
     @pytest.mark.asyncio
     async def test_eth_get_balance(self, async_w3: "AsyncWeb3") -> None:
@@ -4304,7 +4305,7 @@ def test_eth_getBlockByNumber_full_transactions(
         self, w3: "Web3", block_with_txn: BlockData
     ) -> None:
         block = w3.eth.get_block(block_with_txn["number"], True)
-        transaction = block["transactions"][0]
+        transaction = cast(TxData, block["transactions"][0])
         assert transaction["hash"] == block_with_txn["transactions"][0]
 
     def test_eth_getBlockReceipts_hash(
@@ -4771,7 +4772,8 @@ def test_eth_get_raw_transaction_by_block_raises_error_block_identifier(
                 f"{unknown_identifier}"
             ),
         ):
-            w3.eth.get_raw_transaction_by_block(unknown_identifier, 0)
+            # type ignored because we are testing an invalid input
+            w3.eth.get_raw_transaction_by_block(unknown_identifier, 0)  # type: ignore
 
     def test_default_account(
         self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
diff --git a/web3/_utils/module_testing/persistent_connection_provider.py b/web3/_utils/module_testing/persistent_connection_provider.py
@@ -389,7 +389,9 @@ async def test_asyncio_gather_for_multiple_requests_matches_the_responses(
         assert isinstance(pending, AttributeDict)
 
         # assert block values
+        assert latest is not None
         assert all(k in latest.keys() for k in SOME_BLOCK_KEYS)
+        assert pending is not None
         assert all(k in pending.keys() for k in SOME_BLOCK_KEYS)
 
         assert isinstance(block_num, int)
diff --git a/web3/_utils/module_testing/web3_module.py b/web3/_utils/module_testing/web3_module.py
@@ -522,12 +522,12 @@ class AsyncWeb3ModuleTest(Web3ModuleTest):
     # an asynchronous test should have the exact same name.
 
     @pytest.mark.asyncio
-    async def test_web3_client_version(self, async_w3: AsyncWeb3) -> None:
+    async def test_web3_client_version(self, async_w3: AsyncWeb3) -> None:  # type: ignore[override]  # noqa: E501
         client_version = await async_w3.client_version
         self._check_web3_client_version(client_version)
 
     @pytest.mark.asyncio
-    async def test_batch_requests(
+    async def test_batch_requests(  # type: ignore[override]
         self, async_w3: AsyncWeb3, async_math_contract: "AsyncContract"
     ) -> None:
         async with async_w3.batch_requests() as batch:
@@ -595,8 +595,8 @@ async def test_batch_requests(
         assert last_three_responses[2]["number"] == 5
 
     @pytest.mark.asyncio
-    async def test_batch_requests_initialized_as_object(
-        self, async_w3: AsyncWeb3, async_math_contract: "AsyncContract"
+    async def test_batch_requests_initialized_as_object(  # type: ignore[override]
+        self, async_w3: AsyncWeb3, async_math_contract: "AsyncContract"  # type: ignore[override]  # noqa: E501
     ) -> None:
         batch = async_w3.batch_requests()
         batch.add(async_w3.eth.get_block(1))
@@ -643,7 +643,7 @@ async def test_batch_requests_initialized_as_object(
         assert cast(BlockData, b4)["number"] == 4
 
     @pytest.mark.asyncio
-    async def test_batch_requests_clear(self, async_w3: AsyncWeb3) -> None:
+    async def test_batch_requests_clear(self, async_w3: AsyncWeb3) -> None:  # type: ignore[override]  # noqa: E501
         async with async_w3.batch_requests() as batch:
             batch.add(async_w3.eth.get_block(1))
             batch.add(async_w3.eth.get_block(2))
@@ -672,7 +672,7 @@ async def test_batch_requests_clear(self, async_w3: AsyncWeb3) -> None:
         assert cast(BlockData, r3)["number"] == 6
 
     @pytest.mark.asyncio
-    async def test_batch_requests_cancel(self, async_w3: AsyncWeb3) -> None:
+    async def test_batch_requests_cancel(self, async_w3: AsyncWeb3) -> None:  # type: ignore[override]  # noqa: E501
         # as context manager
         async with async_w3.batch_requests() as batch:
             batch.add(async_w3.eth.get_block(1))
@@ -712,8 +712,8 @@ async def test_batch_requests_cancel(self, async_w3: AsyncWeb3) -> None:
         assert isinstance(block_num, int)
 
     @pytest.mark.asyncio
-    async def test_batch_requests_raises_for_common_unsupported_methods(
-        self, async_w3: AsyncWeb3, async_math_contract: "AsyncContract"
+    async def test_batch_requests_raises_for_common_unsupported_methods(  # type: ignore[override]  # noqa: E501
+        self, async_w3: AsyncWeb3, async_math_contract: "AsyncContract"  # type: ignore[override]  # noqa: E501
     ) -> None:
         async with async_w3.batch_requests() as batch:
             with pytest.raises(MethodNotSupported, match="eth_sendTransaction"):
diff --git a/web3/_utils/normalizers.py b/web3/_utils/normalizers.py
@@ -254,7 +254,9 @@ def normalize_abi(abi: Union[ABI, str]) -> ABI:
     return cast(ABI, abi)
 
 
-def normalize_address(ens: ENS, address: ChecksumAddress) -> ChecksumAddress:
+def normalize_address(
+    ens: ENS, address: Optional[ChecksumAddress]
+) -> Union[ChecksumAddress, None]:
     if address:
         if is_ens_name(address):
             validate_name_has_address(ens, address)
@@ -263,15 +265,17 @@ def normalize_address(ens: ENS, address: ChecksumAddress) -> ChecksumAddress:
     return address
 
 
-def normalize_address_no_ens(address: ChecksumAddress) -> ChecksumAddress:
+def normalize_address_no_ens(
+    address: Optional[ChecksumAddress],
+) -> Union[ChecksumAddress, None]:
     if address:
         validate_address(address)
     return address
 
 
-def normalize_bytecode(bytecode: bytes) -> HexBytes:
-    if bytecode:
-        bytecode = HexBytes(bytecode)
+def normalize_bytecode(bytecode: Optional[bytes]) -> Union[HexBytes, None]:
+    if bytecode is not None:
+        return HexBytes(bytecode)
     return bytecode
 
 
diff --git a/web3/contract/base_contract.py b/web3/contract/base_contract.py
diff --git a/web3/contract/utils.py b/web3/contract/utils.py
diff --git a/web3/eth/async_eth.py b/web3/eth/async_eth.py
diff --git a/web3/eth/eth.py b/web3/eth/eth.py
diff --git a/web3/gas_strategies/time_based.py b/web3/gas_strategies/time_based.py
diff --git a/web3/middleware/filter.py b/web3/middleware/filter.py
diff --git a/web3/middleware/signing.py b/web3/middleware/signing.py

Original file line number	Diff line number	Diff line change
`@@ -12,4 +12,5 @@`
`12`	`12`	`NotRequired, # py311`
`13`	`13`	`Self, # py311`
`14`	`14`	`Unpack, # py311`
	`15`	`+ TypeAlias, # py310`
`15`	`16`	`)`