web3 7.11.0__tar.gz → 7.12.0__tar.gz

{web3-7.11.0/web3.egg-info → web3-7.12.0}/PKG-INFO

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

{web3-7.11.0 → web3-7.12.0}/ens/async_ens.py

@@ -57,7 +57,7 @@ from ens.utils import (
     address_in,
     address_to_reverse_domain,
     default,
-    ens_encode_name,
+    dns_encode_name,
     init_async_web3,
     is_empty_name,
     is_none_or_zero_address,
@@ -500,7 +500,7 @@ class AsyncENS(BaseENS):
 
             calldata = resolver.encode_abi(*contract_func_with_args)
             contract_call_result = await resolver.caller.resolve(
-                ens_encode_name(normal_name),
+                dns_encode_name(normal_name),
                 calldata,
             )
             result = self._decode_ensip10_resolve_data(

{web3-7.11.0 → web3-7.12.0}/ens/ens.py

@@ -56,7 +56,7 @@ from .utils import (
     address_in,
     address_to_reverse_domain,
     default,
-    ens_encode_name,
+    dns_encode_name,
     init_web3,
     is_empty_name,
     is_none_or_zero_address,
@@ -482,7 +482,7 @@ class ENS(BaseENS):
 
             calldata = resolver.encode_abi(*contract_func_with_args)
             contract_call_result = resolver.caller.resolve(
-                ens_encode_name(normal_name),
+                dns_encode_name(normal_name),
                 calldata,
             )
             result = self._decode_ensip10_resolve_data(

{web3-7.11.0 → web3-7.12.0}/ens/utils.py

@@ -13,6 +13,7 @@ from typing import (
     Union,
     cast,
 )
+import warnings
 
 from eth_typing import (
     Address,
@@ -132,7 +133,7 @@ def normalize_name(name: str) -> str:
     return normalize_name_ensip15(name).as_text
 
 
-def ens_encode_name(name: str) -> bytes:
+def dns_encode_name(name: str) -> HexBytes:
     r"""
     Encode a name according to DNS standards specified in section 3.1
     of RFC1035 with the following validations:
@@ -145,7 +146,7 @@ def ens_encode_name(name: str) -> bytes:
     :param str name: the dot-separated ENS name
     """
     if is_empty_name(name):
-        return b"\x00"
+        return HexBytes(b"\x00")
 
     normalized_name = normalize_name(name)
 
@@ -163,7 +164,17 @@ def ens_encode_name(name: str) -> bytes:
     dns_prepped_labels = [to_bytes(len(label)) + label for label in labels_as_bytes]
 
     # return the joined prepped labels in order and append the zero byte at the end:
-    return b"".join(dns_prepped_labels) + b"\x00"
+    return HexBytes(b"".join(dns_prepped_labels) + b"\x00")
+
+
+def ens_encode_name(name: str) -> bytes:
+    warnings.warn(
+        "``ens_encode_name`` is deprecated and will be removed in the next "
+        "major version. Use ``dns_encode_name`` instead.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return bytes(dns_encode_name(name))
 
 
 def is_valid_name(name: str) -> bool:

{web3-7.11.0 → web3-7.12.0}/pyproject.toml

@@ -127,7 +127,7 @@ name = "Removals"
 showcontent = true
 
 [tool.bumpversion]
-current_version = "7.11.0"
+current_version = "7.12.0"
 parse = """
     (?P<major>\\d+)
     \\.(?P<minor>\\d+)

{web3-7.11.0 → web3-7.12.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.11.0",
+    version="7.12.0",
     description="""web3: A Python library for interacting with Ethereum""",
     long_description=long_description,
     long_description_content_type="text/markdown",

{web3-7.11.0 → web3-7.12.0}/tests/core/caching-utils/test_request_caching.py

@@ -204,7 +204,7 @@ def test_all_providers_do_not_cache_by_default_and_can_set_caching_properties(pr
     "threshold",
     (RequestCacheValidationThreshold.FINALIZED, RequestCacheValidationThreshold.SAFE),
 )
-@pytest.mark.parametrize("endpoint", BLOCKNUM_IN_PARAMS | BLOCK_IN_RESULT)
+@pytest.mark.parametrize("endpoint", sorted(BLOCKNUM_IN_PARAMS | BLOCK_IN_RESULT))
 @pytest.mark.parametrize(
     "blocknum,should_cache",
     (
@@ -254,7 +254,7 @@ def test_blocknum_validation_against_validation_threshold_when_caching_mainnet(
     "threshold",
     (RequestCacheValidationThreshold.FINALIZED, RequestCacheValidationThreshold.SAFE),
 )
-@pytest.mark.parametrize("endpoint", BLOCKNUM_IN_PARAMS)
+@pytest.mark.parametrize("endpoint", sorted(BLOCKNUM_IN_PARAMS))
 @pytest.mark.parametrize(
     "block_id,blocknum,should_cache",
     (
@@ -297,7 +297,7 @@ def test_block_id_param_caching_mainnet(
     "threshold",
     (RequestCacheValidationThreshold.FINALIZED, RequestCacheValidationThreshold.SAFE),
 )
-@pytest.mark.parametrize("endpoint", BLOCKHASH_IN_PARAMS)
+@pytest.mark.parametrize("endpoint", sorted(BLOCKHASH_IN_PARAMS))
 @pytest.mark.parametrize(
     "blocknum,should_cache",
     (
@@ -360,7 +360,7 @@ def test_request_caching_validation_threshold_defaults(
 
 
 @pytest.mark.parametrize(
-    "endpoint", BLOCKNUM_IN_PARAMS | BLOCK_IN_RESULT | BLOCKHASH_IN_PARAMS
+    "endpoint", sorted(BLOCKNUM_IN_PARAMS | BLOCK_IN_RESULT | BLOCKHASH_IN_PARAMS)
 )
 @pytest.mark.parametrize(
     "time_from_threshold,should_cache",
@@ -436,7 +436,7 @@ def test_sync_validation_against_validation_threshold_time_based(
     ),
 )
 @pytest.mark.parametrize(
-    "endpoint", BLOCKNUM_IN_PARAMS | BLOCK_IN_RESULT | BLOCKHASH_IN_PARAMS
+    "endpoint", sorted(BLOCKNUM_IN_PARAMS | BLOCK_IN_RESULT | BLOCKHASH_IN_PARAMS)
 )
 def test_validation_against_validation_threshold_time_based_configured(
     time_from_threshold, should_cache, chain_id, endpoint, sync_provider, request_mocker
@@ -642,7 +642,7 @@ async def test_async_request_caching_does_not_share_state_between_providers(
     "threshold",
     (RequestCacheValidationThreshold.FINALIZED, RequestCacheValidationThreshold.SAFE),
 )
-@pytest.mark.parametrize("endpoint", BLOCKNUM_IN_PARAMS | BLOCK_IN_RESULT)
+@pytest.mark.parametrize("endpoint", sorted(BLOCKNUM_IN_PARAMS | BLOCK_IN_RESULT))
 @pytest.mark.parametrize(
     "blocknum,should_cache",
     (
@@ -689,7 +689,7 @@ async def test_async_blocknum_validation_against_validation_threshold_mainnet(
     "threshold",
     (RequestCacheValidationThreshold.FINALIZED, RequestCacheValidationThreshold.SAFE),
 )
-@pytest.mark.parametrize("endpoint", BLOCKNUM_IN_PARAMS)
+@pytest.mark.parametrize("endpoint", sorted(BLOCKNUM_IN_PARAMS))
 @pytest.mark.parametrize(
     "block_id,blocknum,should_cache",
     (
@@ -735,7 +735,7 @@ async def test_async_block_id_param_caching_mainnet(
     "threshold",
     (RequestCacheValidationThreshold.FINALIZED, RequestCacheValidationThreshold.SAFE),
 )
-@pytest.mark.parametrize("endpoint", BLOCKHASH_IN_PARAMS)
+@pytest.mark.parametrize("endpoint", sorted(BLOCKHASH_IN_PARAMS))
 @pytest.mark.parametrize(
     "blocknum,should_cache",
     (
@@ -794,7 +794,7 @@ async def test_async_request_caching_validation_threshold_defaults(
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
-    "endpoint", BLOCKNUM_IN_PARAMS | BLOCK_IN_RESULT | BLOCKHASH_IN_PARAMS
+    "endpoint", sorted(BLOCKNUM_IN_PARAMS | BLOCK_IN_RESULT | BLOCKHASH_IN_PARAMS)
 )
 @pytest.mark.parametrize(
     "time_from_threshold,should_cache",
@@ -856,7 +856,7 @@ async def test_async_validation_against_validation_threshold_time_based(
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
-    "endpoint", BLOCKNUM_IN_PARAMS | BLOCK_IN_RESULT | BLOCKHASH_IN_PARAMS
+    "endpoint", sorted(BLOCKNUM_IN_PARAMS | BLOCK_IN_RESULT | BLOCKHASH_IN_PARAMS)
 )
 @pytest.mark.parametrize("blocknum", ("0x0", "0x1", "0x2", "0x3", "0x4", "0x5"))
 async def test_async_request_caching_with_validation_threshold_set_to_none(
@@ -901,7 +901,7 @@ async def test_async_request_caching_with_validation_threshold_set_to_none(
     ),
 )
 @pytest.mark.parametrize(
-    "endpoint", BLOCKNUM_IN_PARAMS | BLOCK_IN_RESULT | BLOCKHASH_IN_PARAMS
+    "endpoint", sorted(BLOCKNUM_IN_PARAMS | BLOCK_IN_RESULT | BLOCKHASH_IN_PARAMS)
 )
 async def test_async_validation_against_validation_threshold_time_based_configured(
     time_from_threshold,

{web3-7.11.0 → web3-7.12.0}/tests/core/contracts/test_contract_init.py

@@ -85,7 +85,7 @@ def test_init_multiple_contracts_performance(w3, emitter_contract_data):
             abi=emitter_contract_data["abi"], bytecode=emitter_contract_data["bytecode"]
         )
     # assert initializing 500 contracts is within a conservative / reasonable time
-    assert (time.time() - start_time) < 1.75
+    assert (time.time() - start_time) < 3
 
 
 # -- async -- #
@@ -98,4 +98,4 @@ def test_async_init_multiple_contracts_performance(async_w3, emitter_contract_da
             abi=emitter_contract_data["abi"], bytecode=emitter_contract_data["bytecode"]
         )
     # assert initializing 500 contracts is within a conservative / reasonable time
-    assert (time.time() - start_time) < 1.75
+    assert (time.time() - start_time) < 3

{web3-7.11.0 → web3-7.12.0}/tests/core/middleware/test_eth_tester_middleware.py

@@ -18,7 +18,7 @@ SAMPLE_ADDRESS_LIST = [
 SAMPLE_ADDRESS = "0x0000000000000000000000000000000000000004"
 
 
-@pytest.mark.parametrize("block_number", {0, "0x0", "earliest"})
+@pytest.mark.parametrize("block_number", (0, "0x0", "earliest"))
 def test_get_transaction_count_formatters(w3, block_number):
     tx_counts = w3.eth.get_transaction_count(w3.eth.accounts[-1], block_number)
     assert tx_counts == 0

{web3-7.11.0 → web3-7.12.0}/tests/core/providers/test_async_http_provider.py

@@ -128,23 +128,4 @@ async def test_async_http_empty_batch_response(mock_async_post):
         with pytest.raises(Web3RPCError, match="empty batch"):
             await batch.async_execute()
 
-    # assert that even though there was an error, we have reset the batching state
     assert not async_w3.provider._is_batching
-
-
-@patch(
-    "web3._utils.http_session_manager.HTTPSessionManager.async_make_post_request",
-    new_callable=AsyncMock,
-)
-@pytest.mark.asyncio
-async def test_async_provider_is_batching_when_make_batch_request(mock_post):
-    def assert_is_batching_and_return_response(*_args, **_kwargs) -> bytes:
-        assert provider._is_batching
-        return b'{"jsonrpc":"2.0","id":1,"result":["0x1"]}'
-
-    mock_post.side_effect = assert_is_batching_and_return_response
-    provider = AsyncHTTPProvider()
-
-    assert not provider._is_batching
-    await provider.make_batch_request([("eth_blockNumber", [])])
-    assert not provider._is_batching

{web3-7.11.0 → web3-7.12.0}/tests/core/providers/test_async_ipc_provider.py

@@ -374,16 +374,18 @@ async def test_persistent_connection_provider_empty_batch_response(
     simple_ipc_server,
     jsonrpc_ipc_pipe_path,
 ):
-    async with AsyncWeb3(
-        AsyncIPCProvider(pathlib.Path(jsonrpc_ipc_pipe_path))
-    ) as async_w3:
-        async_w3.provider._reader.readline = AsyncMock()
-        async_w3.provider._reader.readline.return_value = (
-            b'{"jsonrpc": "2.0","id":null,"error": {"code": -32600, "message": '
-            b'"empty batch"}}\n'
-        )
-        async with async_w3.batch_requests() as batch:
-            with pytest.raises(Web3RPCError, match="empty batch"):
+    with pytest.raises(Web3RPCError, match="empty batch"):
+        async with AsyncWeb3(
+            AsyncIPCProvider(pathlib.Path(jsonrpc_ipc_pipe_path))
+        ) as async_w3:
+            async_w3.provider._reader.readline = AsyncMock(
+                return_value=(
+                    b'{"jsonrpc": "2.0","id":null,"error": {"code": -32600, "message": '
+                    b'"empty batch"}}\n'
+                )
+            )
+            async with async_w3.batch_requests() as batch:
+                assert async_w3.provider._is_batching
                 await batch.async_execute()
 
         # assert that even though there was an error, we have reset the batching state

{web3-7.11.0 → web3-7.12.0}/tests/core/providers/test_http_provider.py

@@ -127,26 +127,9 @@ def test_http_empty_batch_response(mock_post):
     )
     w3 = Web3(HTTPProvider())
     with w3.batch_requests() as batch:
+        assert w3.provider._is_batching
         with pytest.raises(Web3RPCError, match="empty batch"):
             batch.execute()
 
     # assert that even though there was an error, we have reset the batching state
     assert not w3.provider._is_batching
-
-
-@patch(
-    "web3._utils.http_session_manager.HTTPSessionManager.make_post_request",
-    new_callable=Mock,
-)
-def test_sync_provider_is_batching_when_make_batch_request(mock_post):
-    def assert_is_batching_and_return_response(*_args, **_kwargs) -> bytes:
-        assert provider._is_batching
-        return b'{"jsonrpc":"2.0","id":1,"result":["0x1"]}'
-
-    provider = HTTPProvider()
-    assert not provider._is_batching
-
-    mock_post.side_effect = assert_is_batching_and_return_response
-
-    provider.make_batch_request([("eth_blockNumber", [])])
-    assert not provider._is_batching

{web3-7.11.0 → web3-7.12.0}/tests/core/providers/test_ipc_provider.py

@@ -199,18 +199,3 @@ def test_ipc_provider_write_messages_end_with_new_line_delimiter(jsonrpc_ipc_pip
 
     request_data = b'{"jsonrpc": "2.0", "method": "method", "params": [], "id": 0}'
     provider._socket.sock.sendall.assert_called_with(request_data + b"\n")
-
-
-def test_ipc_provider_is_batching_when_make_batch_request(jsonrpc_ipc_pipe_path):
-    def assert_is_batching_and_return_response(*_args, **_kwargs) -> bytes:
-        assert provider._is_batching
-        return [{"id": 0, "jsonrpc": "2.0", "result": {}}]
-
-    provider = IPCProvider(pathlib.Path(jsonrpc_ipc_pipe_path), timeout=3)
-    provider._make_request = Mock()
-    provider._make_request.side_effect = assert_is_batching_and_return_response
-
-    assert not provider._is_batching
-
-    provider.make_batch_request([("eth_blockNumber", [])])
-    assert not provider._is_batching

{web3-7.11.0 → web3-7.12.0}/tests/core/providers/test_websocket_provider.py

@@ -397,7 +397,7 @@ async def test_async_iterator_pattern_exception_handling_for_subscriptions():
 
 
 @pytest.mark.asyncio
-async def test_connection_closed_ok_breaks_message_iteration():
+async def test_connection_closed_ok_breaks_process_subscriptions_iteration():
     with patch(
         "web3.providers.persistent.websocket.connect",
         new=lambda *_1, **_2: WebSocketMessageStreamMock(
@@ -409,6 +409,22 @@ async def test_connection_closed_ok_breaks_message_iteration():
             pytest.fail("Should not reach this point.")
 
 
+@pytest.mark.asyncio
+async def test_connection_closed_ok_breaks_handle_subscriptions_iteration():
+    with patch(
+        "web3.providers.persistent.websocket.connect",
+        new=lambda *_1, **_2: WebSocketMessageStreamMock(
+            raise_exception=ConnectionClosedOK(None, None)
+        ),
+    ):
+        w3 = await AsyncWeb3(WebSocketProvider("ws://mocked"))
+        # would fail with a ``TimeoutError`` if the iteration did not break properly
+        # on ``ConnectionClosedOK``
+        await asyncio.wait_for(
+            w3.subscription_manager.handle_subscriptions(run_forever=True), timeout=1
+        )
+
+
 @pytest.mark.asyncio
 async def test_listener_task_breaks_out_of_stream_when_cancelled():
     with patch(
@@ -457,19 +473,20 @@ async def test_persistent_connection_provider_empty_batch_response():
         "web3.providers.persistent.websocket.connect",
         new=lambda *_1, **_2: _mocked_ws_conn(),
     ):
-        async with AsyncWeb3(WebSocketProvider("ws://mocked")) as async_w3:
-            async_w3.provider._ws.recv = AsyncMock()
-            async_w3.provider._ws.recv.return_value = (
-                b'{"jsonrpc": "2.0","id":null,"error": {"code": -32600, "message": '
-                b'"empty batch"}}\n'
-            )
-            async with async_w3.batch_requests() as batch:
-                with pytest.raises(Web3RPCError, match="empty batch"):
+        with pytest.raises(Web3RPCError, match="empty batch"):
+            async with AsyncWeb3(WebSocketProvider("ws://mocked")) as async_w3:
+                async with async_w3.batch_requests() as batch:
+                    assert async_w3.provider._is_batching
+                    async_w3.provider._ws.recv = AsyncMock()
+                    async_w3.provider._ws.recv.return_value = (
+                        b'{"jsonrpc": "2.0","id":null,"error": {"code": -32600, '
+                        b'"message": "empty batch"}}\n'
+                    )
                     await batch.async_execute()
 
-            # assert that even though there was an error, we have reset the batching
-            # state
-            assert not async_w3.provider._is_batching
+        # assert that even though there was an error, we have reset the batching
+        # state
+        assert not async_w3.provider._is_batching
 
 
 @pytest.mark.parametrize(
@@ -548,21 +565,3 @@ async def test_raise_stray_errors_from_cache_handles_list_response_without_error
 
     # assert no errors raised
     provider._raise_stray_errors_from_cache()
-
-
-@pytest.mark.asyncio
-async def test_websocket_provider_is_batching_when_make_batch_request():
-    def assert_is_batching_and_return_response(*_args, **_kwargs) -> bytes:
-        assert provider._is_batching
-        return b'{"jsonrpc":"2.0","id":1,"result":["0x1"]}'
-
-    provider = WebSocketProvider("ws://mocked")
-    _mock_ws(provider)
-    provider._get_response_for_request_id = AsyncMock()
-    provider._get_response_for_request_id.side_effect = (
-        assert_is_batching_and_return_response
-    )
-
-    assert not provider._is_batching
-    await provider.make_batch_request([("eth_blockNumber", [])])
-    assert not provider._is_batching

{web3-7.11.0 → web3-7.12.0}/tests/core/utilities/test_abi.py

@@ -829,7 +829,7 @@ def test_get_event_abi(event_name: str, input_args: Sequence[ABIComponent]) -> N
 
     with pytest.warns(
         DeprecationWarning,
-        match="get_event_abi is deprecated in favor of get_abi_element",
+        match="get_event_abi is deprecated: use get_abi_element instead",
     ):
         assert (
             get_event_abi(contract_abi, event_name, input_names) == expected_event_abi