web3 7.13.0__tar.gz → 7.14.0__tar.gz

{web3-7.13.0/web3.egg-info → web3-7.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: web3
-Version: 7.13.0
+Version: 7.14.0
 Summary: web3: A Python library for interacting with Ethereum
 Home-page: https://github.com/ethereum/web3.py
 Author: The Ethereum Foundation

{web3-7.13.0 → web3-7.14.0}/ens/async_ens.py

@@ -72,7 +72,9 @@ if TYPE_CHECKING:
         AsyncContract,
         AsyncContractFunction,
     )
-    from web3.main import AsyncWeb3  # noqa: F401
+    from web3.main import (  # noqa: F401
+        AsyncWeb3,
+    )
     from web3.middleware.base import (  # noqa: F401
         Middleware,
     )
@@ -96,12 +98,12 @@ class AsyncENS(BaseENS):
     """
 
     # mypy types
-    w3: "AsyncWeb3"
+    w3: "AsyncWeb3[Any]"
 
     def __init__(
         self,
-        provider: "AsyncBaseProvider" = None,
-        addr: ChecksumAddress = None,
+        provider: Optional["AsyncBaseProvider"] = None,
+        addr: Optional[ChecksumAddress] = None,
         middleware: Optional[Sequence[Tuple["Middleware", str]]] = None,
     ) -> None:
         """
@@ -123,7 +125,9 @@ class AsyncENS(BaseENS):
         )
 
     @classmethod
-    def from_web3(cls, w3: "AsyncWeb3", addr: ChecksumAddress = None) -> "AsyncENS":
+    def from_web3(
+        cls, w3: "AsyncWeb3[Any]", addr: ChecksumAddress = None
+    ) -> "AsyncENS":
         """
         Generate an AsyncENS instance with web3
 

{web3-7.13.0 → web3-7.14.0}/ens/base_ens.py

@@ -38,7 +38,7 @@ if TYPE_CHECKING:
 
 
 class BaseENS:
-    w3: Union["AsyncWeb3", "Web3"] = None
+    w3: Union["AsyncWeb3[Any]", "Web3"] = None
     ens: Union["Contract", "AsyncContract"] = None
     _resolver_contract: Union[Type["Contract"], Type["AsyncContract"]] = None
     _reverse_resolver_contract: Union[Type["Contract"], Type["AsyncContract"]] = None

{web3-7.13.0 → web3-7.14.0}/ens/utils.py

@@ -302,7 +302,7 @@ def is_valid_ens_name(ens_name: str) -> bool:
 def init_async_web3(
     provider: "AsyncBaseProvider" = None,
     middleware: Optional[Sequence[Tuple["Middleware", str]]] = (),
-) -> "AsyncWeb3":
+) -> "AsyncWeb3[Any]":
     from web3 import (
         AsyncWeb3 as AsyncWeb3Main,
     )
@@ -327,6 +327,7 @@ def init_async_web3(
             )
         )
 
+    async_w3: "AsyncWeb3[Any]"
     if provider is default:
         async_w3 = AsyncWeb3Main(
             middleware=middleware, ens=None, modules={"eth": (AsyncEthMain)}

{web3-7.13.0 → web3-7.14.0}/pyproject.toml

@@ -15,7 +15,7 @@ multi_line_output = 3
 profile = "black"
 use_parentheses = true
 # skip `__init__.py` files because sometimes order of initialization is important
-skip="__init__.py,web3/main.py,web3/utils/windows.py"
+skip="__init__.py,web3/main.py,web3/_utils/windows.py"
 
 [tool.mypy]
 check_untyped_defs = true
@@ -127,7 +127,7 @@ name = "Removals"
 showcontent = true
 
 [tool.bumpversion]
-current_version = "7.13.0"
+current_version = "7.14.0"
 parse = """
     (?P<major>\\d+)
     \\.(?P<minor>\\d+)

{web3-7.13.0 → web3-7.14.0}/setup.py

@@ -55,7 +55,7 @@ with open("./README.md") as readme:
 setup(
     name="web3",
     # *IMPORTANT*: Don't manually change the version here. See Contributing docs for the release process.
-    version="7.13.0",
+    version="7.14.0",
     description="""web3: A Python library for interacting with Ethereum""",
     long_description=long_description,
     long_description_content_type="text/markdown",

{web3-7.13.0 → web3-7.14.0}/tests/core/caching-utils/test_generate_cache_key.py

@@ -4,7 +4,9 @@ from eth_utils import (
     to_dict,
 )
 from hypothesis import (
+    HealthCheck,
     given,
+    settings,
     strategies as st,
 )
 
@@ -42,6 +44,9 @@ def recursive_shuffle_dict(v):
         return v
 
 
+# Generating data for the `all_st` strategy can be slow, so we disable the
+# "too_slow" health check for this test.
+@settings(suppress_health_check=[HealthCheck.too_slow])
 @given(value=all_st)
 def test_key_generation_is_deterministic(value):
     left = recursive_shuffle_dict(value)

{web3-7.13.0 → web3-7.14.0}/tests/core/contracts/test_contract_call_interface.py

@@ -238,8 +238,8 @@ def test_call_get_byte_array_non_strict(non_strict_arrays_contract, call):
     "args,expected",
     [
         ([b"1"], [b"1"]),
-        (["0xDe"], [b"\xDe"]),
-        (["0xDe", "0xDe"], [b"\xDe", b"\xDe"]),
+        (["0xDe"], [b"\xde"]),
+        (["0xDe", "0xDe"], [b"\xde", b"\xde"]),
     ],
 )
 def test_set_byte_array(arrays_contract, call, transact, args, expected):
@@ -257,8 +257,8 @@ def test_set_byte_array(arrays_contract, call, transact, args, expected):
     "args,expected",
     [
         ([b"1"], [b"1"]),
-        (["0xDe"], [b"\xDe"]),
-        (["0xDe", "0xDe"], [b"\xDe", b"\xDe"]),
+        (["0xDe"], [b"\xde"]),
+        (["0xDe", "0xDe"], [b"\xde", b"\xde"]),
     ],
 )
 def test_set_byte_array_non_strict(
@@ -1503,7 +1503,7 @@ async def test_async_set_byte_array_non_strict(
 
 
 @pytest.mark.asyncio
-@pytest.mark.parametrize("args,expected", [([b"1"], [b"1"]), (["0xDe"], [b"\xDe"])])
+@pytest.mark.parametrize("args,expected", [([b"1"], [b"1"]), (["0xDe"], [b"\xde"])])
 async def test_async_set_byte_array_strict_by_default(
     async_arrays_contract, async_call, async_transact, args, expected
 ):

{web3-7.13.0 → web3-7.14.0}/tests/core/utilities/test_abi.py

@@ -249,8 +249,8 @@ def test_get_tuple_type_str_parts(
     [
         (
             ["bool[2]", "bytes"],
-            [[True, False], b"\x00\xFF"],
-            [("bool[2]", [("bool", True), ("bool", False)]), ("bytes", b"\x00\xFF")],
+            [[True, False], b"\x00\xff"],
+            [("bool[2]", [("bool", True), ("bool", False)]), ("bytes", b"\x00\xff")],
         ),
         (
             ["uint256[]"],
@@ -337,7 +337,7 @@ def test_map_abi_data(
 
 @pytest.mark.parametrize("arg", (6, 7, 9, 12, 20, 30))
 def test_exact_length_bytes_encoder_raises_on_non_multiples_of_8_bit_size(
-    arg: Tuple[int, ...]
+    arg: Tuple[int, ...],
 ) -> None:
     with pytest.raises(Web3ValueError, match="multiple of 8"):
         _ = ExactLengthBytesEncoder(None, data_byte_size=2, value_bit_size=arg)

{web3-7.13.0 → web3-7.14.0}/tests/core/utilities/test_encoding.py

@@ -144,8 +144,11 @@ def test_text_if_str_on_text(val):
         ),
         (
             {
-                "date": [datetime.datetime.utcnow(), datetime.datetime.now()],
-                "other_date": datetime.datetime.utcnow().date(),
+                "date": [
+                    datetime.datetime.now(datetime.timezone.utc),
+                    datetime.datetime.now(),
+                ],
+                "other_date": datetime.datetime.now(datetime.timezone.utc).date(),
             },
             TypeError,
             "Could not encode to JSON: .*'other_date'.*is not JSON serializable",

{web3-7.13.0 → web3-7.14.0}/tests/core/web3-module/test_conversions.py

@@ -159,7 +159,7 @@ def test_to_int_hexstr(val, expected):
         (b"\x01", "0x01"),
         (b"\x10", "0x10"),
         (b"\x01\x00", "0x0100"),
-        (b"\x00\x0F", "0x000f"),
+        (b"\x00\x0f", "0x000f"),
         (b"", "0x"),
         (0, "0x0"),
         (1, "0x1"),

{web3-7.13.0 → web3-7.14.0}/tests/integration/go_ethereum/conftest.py

@@ -175,12 +175,14 @@ def start_geth_process_and_yield_port(
         bufsize=1,
     )
 
-    port = wait_for_port(proc)
-    yield port
-
-    kill_proc_gracefully(proc)
-    output, errors = proc.communicate(timeout=5)
-    print("Geth Process Exited:\n" f"stdout: {output}\n\n" f"stderr: {errors}\n\n")
+    try:
+        port = wait_for_port(proc)
+        yield port
+    finally:
+        # Ensure cleanup happens even if test fails
+        kill_proc_gracefully(proc)
+        output, errors = proc.communicate(timeout=5)
+        print("Geth Process Exited:\n" f"stdout: {output}\n\n" f"stderr: {errors}\n\n")
 
 
 @pytest.fixture

{web3-7.13.0 → web3-7.14.0}/web3/_utils/abi.py

@@ -852,7 +852,7 @@ def _named_subtree(
 
 def recursive_dict_to_namedtuple(data: Dict[str, Any]) -> Tuple[Any, ...]:
     def _dict_to_namedtuple(
-        value: Union[Dict[str, Any], List[Any]]
+        value: Union[Dict[str, Any], List[Any]],
     ) -> Union[Tuple[Any, ...], List[Any]]:
         if not isinstance(value, dict):
             return value
@@ -864,7 +864,7 @@ def recursive_dict_to_namedtuple(data: Dict[str, Any]) -> Tuple[Any, ...]:
 
 
 def abi_decoded_namedtuple_factory(
-    fields: Tuple[Any, ...]
+    fields: Tuple[Any, ...],
 ) -> Callable[..., Tuple[Any, ...]]:
     class ABIDecodedNamedTuple(namedtuple("ABIDecodedNamedTuple", fields, rename=True)):  # type: ignore # noqa: E501
         def __new__(self, args: Any) -> "ABIDecodedNamedTuple":
@@ -877,9 +877,9 @@ def abi_decoded_namedtuple_factory(
 
 
 async def async_data_tree_map(
-    async_w3: "AsyncWeb3",
+    async_w3: "AsyncWeb3[Any]",
     func: Callable[
-        ["AsyncWeb3", TypeStr, Any], Coroutine[Any, Any, Tuple[TypeStr, Any]]
+        ["AsyncWeb3[Any]", TypeStr, Any], Coroutine[Any, Any, Tuple[TypeStr, Any]]
     ],
     data_tree: Any,
 ) -> "ABITypedData":
@@ -902,7 +902,7 @@ async def async_data_tree_map(
 
 @reject_recursive_repeats
 async def async_recursive_map(
-    async_w3: "AsyncWeb3",
+    async_w3: "AsyncWeb3[Any]",
     func: Callable[[Any], Coroutine[Any, Any, TReturn]],
     data: Any,
 ) -> TReturn:

{web3-7.13.0 → web3-7.14.0}/web3/_utils/async_transactions.py

@@ -1,5 +1,6 @@
 from typing import (
     TYPE_CHECKING,
+    Any,
     Dict,
     Optional,
     Union,
@@ -46,13 +47,13 @@ if TYPE_CHECKING:
 
 # unused vars present in these funcs because they all need to have the same signature
 async def _estimate_gas(
-    async_w3: "AsyncWeb3", tx: TxParams, _defaults: Dict[str, Union[bytes, int]]
+    async_w3: "AsyncWeb3[Any]", tx: TxParams, _defaults: Dict[str, Union[bytes, int]]
 ) -> int:
     return await async_w3.eth.estimate_gas(tx)
 
 
 async def _max_fee_per_gas(
-    async_w3: "AsyncWeb3", tx: TxParams, defaults: Dict[str, Union[bytes, int]]
+    async_w3: "AsyncWeb3[Any]", tx: TxParams, defaults: Dict[str, Union[bytes, int]]
 ) -> Wei:
     block = await async_w3.eth.get_block("latest")
     max_priority_fee = tx.get(
@@ -62,13 +63,13 @@ async def _max_fee_per_gas(
 
 
 async def _max_priority_fee_gas(
-    async_w3: "AsyncWeb3", _tx: TxParams, _defaults: Dict[str, Union[bytes, int]]
+    async_w3: "AsyncWeb3[Any]", _tx: TxParams, _defaults: Dict[str, Union[bytes, int]]
 ) -> Wei:
     return await async_w3.eth.max_priority_fee
 
 
 async def _chain_id(
-    async_w3: "AsyncWeb3", _tx: TxParams, _defaults: Dict[str, Union[bytes, int]]
+    async_w3: "AsyncWeb3[Any]", _tx: TxParams, _defaults: Dict[str, Union[bytes, int]]
 ) -> int:
     return await async_w3.eth.chain_id
 
@@ -92,7 +93,7 @@ async def get_block_gas_limit(
 
 
 async def get_buffered_gas_estimate(
-    async_w3: "AsyncWeb3", transaction: TxParams, gas_buffer: int = 100000
+    async_w3: "AsyncWeb3[Any]", transaction: TxParams, gas_buffer: int = 100000
 ) -> int:
     gas_estimate_transaction = cast(TxParams, dict(**transaction))
 
@@ -110,7 +111,9 @@ async def get_buffered_gas_estimate(
     return min(gas_limit, gas_estimate + gas_buffer)
 
 
-async def async_fill_nonce(async_w3: "AsyncWeb3", transaction: TxParams) -> TxParams:
+async def async_fill_nonce(
+    async_w3: "AsyncWeb3[Any]", transaction: TxParams
+) -> TxParams:
     if "from" in transaction and "nonce" not in transaction:
         tx_count = await async_w3.eth.get_transaction_count(
             cast(ChecksumAddress, transaction["from"]),
@@ -121,7 +124,7 @@ async def async_fill_nonce(async_w3: "AsyncWeb3", transaction: TxParams) -> TxPa
 
 
 async def async_fill_transaction_defaults(
-    async_w3: "AsyncWeb3", transaction: TxParams
+    async_w3: "AsyncWeb3[Any]", transaction: TxParams
 ) -> TxParams:
     """
     If async_w3 is None, fill as much as possible while offline
@@ -165,7 +168,7 @@ async def async_fill_transaction_defaults(
 
 
 async def async_get_required_transaction(
-    async_w3: "AsyncWeb3", transaction_hash: _Hash32
+    async_w3: "AsyncWeb3[Any]", transaction_hash: _Hash32
 ) -> TxData:
     current_transaction = await async_w3.eth.get_transaction(transaction_hash)
     if not current_transaction:
@@ -176,7 +179,7 @@ async def async_get_required_transaction(
 
 
 async def async_replace_transaction(
-    async_w3: "AsyncWeb3", current_transaction: TxData, new_transaction: TxParams
+    async_w3: "AsyncWeb3[Any]", current_transaction: TxData, new_transaction: TxParams
 ) -> HexBytes:
     new_transaction = prepare_replacement_transaction(
         async_w3, current_transaction, new_transaction

{web3-7.13.0 → web3-7.14.0}/web3/_utils/batching.py

@@ -71,7 +71,7 @@ RPC_METHODS_UNSUPPORTED_DURING_BATCH = {
 
 
 class RequestBatcher(Generic[TFunc]):
-    def __init__(self, web3: Union["AsyncWeb3", "Web3"]) -> None:
+    def __init__(self, web3: Union["AsyncWeb3[Any]", "Web3"]) -> None:
         self.web3 = web3
         self._requests_info: List[BatchRequestInformation] = []
         self._async_requests_info: List[

{web3-7.13.0 → web3-7.14.0}/web3/_utils/caching/caching_utils.py

@@ -238,7 +238,7 @@ def _should_cache_response(
 
 
 def handle_request_caching(
-    func: Callable[[SYNC_PROVIDER_TYPE, RPCEndpoint, Any], "RPCResponse"]
+    func: Callable[[SYNC_PROVIDER_TYPE, RPCEndpoint, Any], "RPCResponse"],
 ) -> Callable[..., "RPCResponse"]:
     def wrapper(
         provider: SYNC_PROVIDER_TYPE, method: RPCEndpoint, params: Any
@@ -401,7 +401,7 @@ def async_handle_recv_caching(
     func: Callable[
         ["PersistentConnectionProvider", "RPCRequest"],
         Coroutine[Any, Any, "RPCResponse"],
-    ]
+    ],
 ) -> Callable[..., Coroutine[Any, Any, "RPCResponse"]]:
     async def wrapper(
         provider: "PersistentConnectionProvider",

{web3-7.13.0 → web3-7.14.0}/web3/_utils/contracts.py

@@ -121,7 +121,7 @@ def find_matching_event_abi(
 
 
 def encode_abi(
-    w3: Union["AsyncWeb3", "Web3"],
+    w3: Union["AsyncWeb3[Any]", "Web3"],
     abi: ABIElement,
     arguments: Sequence[Any],
     data: Optional[HexStr] = None,
@@ -168,7 +168,7 @@ def encode_abi(
 
 def prepare_transaction(
     address: ChecksumAddress,
-    w3: Union["AsyncWeb3", "Web3"],
+    w3: Union["AsyncWeb3[Any]", "Web3"],
     abi_element_identifier: ABIElementIdentifier,
     contract_abi: Optional[ABI] = None,
     abi_callable: Optional[ABICallable] = None,
@@ -232,7 +232,7 @@ def prepare_transaction(
 
 
 def encode_transaction_data(
-    w3: Union["AsyncWeb3", "Web3"],
+    w3: Union["AsyncWeb3[Any]", "Web3"],
     abi_element_identifier: ABIElementIdentifier,
     contract_abi: Optional[ABI] = None,
     abi_callable: Optional[ABICallable] = None,
@@ -363,7 +363,7 @@ def parse_block_identifier_int(w3: "Web3", block_identifier_int: int) -> BlockNu
 
 
 async def async_parse_block_identifier(
-    async_w3: "AsyncWeb3", block_identifier: BlockIdentifier
+    async_w3: "AsyncWeb3[Any]", block_identifier: BlockIdentifier
 ) -> BlockIdentifier:
     if block_identifier is None:
         return async_w3.eth.default_block
@@ -381,7 +381,7 @@ async def async_parse_block_identifier(
 
 
 async def async_parse_block_identifier_int(
-    async_w3: "AsyncWeb3", block_identifier_int: int
+    async_w3: "AsyncWeb3[Any]", block_identifier_int: int
 ) -> BlockNumber:
     if block_identifier_int >= 0:
         block_num = block_identifier_int

{web3-7.13.0 → web3-7.14.0}/web3/_utils/ens.py

@@ -75,7 +75,7 @@ class AsyncStaticENS:
 
 @contextmanager
 def ens_addresses(
-    w3: Union["Web3", "AsyncWeb3"], name_addr_pairs: Dict[str, ChecksumAddress]
+    w3: Union["Web3", "AsyncWeb3[Any]"], name_addr_pairs: Dict[str, ChecksumAddress]
 ) -> Iterator[None]:
     original_ens = w3.ens
     if w3.provider.is_async:

{web3-7.13.0 → web3-7.14.0}/web3/_utils/events.py

@@ -453,7 +453,7 @@ class EventFilterBuilder(BaseEventFilterBuilder):
 
 
 class AsyncEventFilterBuilder(BaseEventFilterBuilder):
-    async def deploy(self, async_w3: "AsyncWeb3") -> "AsyncLogFilter":
+    async def deploy(self, async_w3: "AsyncWeb3[Any]") -> "AsyncLogFilter":
         if not isinstance(async_w3, web3.AsyncWeb3):
             raise Web3ValueError(f"Invalid web3 argument: got: {async_w3!r}")