web3 7.11.1__tar.gz → 7.12.1__tar.gz

{web3-7.11.1/web3.egg-info → web3-7.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: web3
-Version: 7.11.1
+Version: 7.12.1
 Summary: web3: A Python library for interacting with Ethereum
 Home-page: https://github.com/ethereum/web3.py
 Author: The Ethereum Foundation
@@ -78,6 +78,19 @@ Requires-Dist: mypy==1.10.0; extra == "test"
 Requires-Dist: pre-commit>=3.4.0; extra == "test"
 Requires-Dist: eth-tester[py-evm]<0.14.0b1,>=0.13.0b1; extra == "test"
 Requires-Dist: py-geth>=5.1.0; extra == "test"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # web3.py
 

{web3-7.11.1 → web3-7.12.1}/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.1 → web3-7.12.1}/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.1 → web3-7.12.1}/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.1 → web3-7.12.1}/pyproject.toml

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

{web3-7.11.1 → web3-7.12.1}/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.1",
+    version="7.12.1",
     description="""web3: A Python library for interacting with Ethereum""",
     long_description=long_description,
     long_description_content_type="text/markdown",

{web3-7.11.1 → web3-7.12.1}/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.1 → web3-7.12.1}/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.1 → web3-7.12.1}/tests/core/eth-module/test_accounts.py

@@ -264,6 +264,7 @@ def test_eth_account_sign(
     acct, message_text, key, expected_bytes, expected_hash, v, r, s, signature
 ):
     message = encode_defunct(text=message_text)
+    assert message.body == expected_bytes
     signed_message = Web3.keccak(
         b"\x19Ethereum Signed Message:\n"
         + bytes(f"{len(message.body)}", encoding="utf-8")
@@ -357,9 +358,9 @@ def test_eth_account_sign(
         ),
         (
             {
-                "gas": 100000,
-                "maxFeePerGas": 2000000000,
-                "maxPriorityFeePerGas": 2000000000,
+                "gas": "0x186a0",
+                "maxFeePerGas": "0x77359400",
+                "maxPriorityFeePerGas": "0x77359400",
                 "data": "0x5544",
                 "nonce": "0x2",
                 "to": "0x96216849c49358B10257cb55b28eA603c874b05E",

{web3-7.11.1 → web3-7.12.1}/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.1 → web3-7.12.1}/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.1 → web3-7.12.1}/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.1 → web3-7.12.1}/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.1 → web3-7.12.1}/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.1 → web3-7.12.1}/tests/core/providers/test_websocket_provider.py

@@ -473,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(
@@ -564,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.1 → web3-7.12.1}/tests/core/utilities/test_http_session_manager.py

@@ -87,7 +87,7 @@ def _simulate_call(http_session_manager, uri):
     return _session
 
 
-@pytest.fixture(scope="function")
+@pytest.fixture
 def http_session_manager():
     return HTTPSessionManager()
 
@@ -342,7 +342,7 @@ async def test_session_manager_async_json_make_get_request(
     response = await http_session_manager.async_json_make_get_request(TEST_URI)
     assert response == json.dumps({"data": "content"})
     assert len(http_session_manager.session_cache) == 1
-    cache_key = generate_cache_key(f"{threading.get_ident()}:{TEST_URI}")
+    cache_key = generate_cache_key(f"{id(asyncio.get_event_loop())}:{TEST_URI}")
     session = http_session_manager.session_cache.get_cache_entry(cache_key)
     assert isinstance(session, ClientSession)
     session.get.assert_called_once_with(
@@ -367,7 +367,7 @@ async def test_session_manager_async_json_make_post_request(
     )
     assert response == json.dumps({"data": "content"})
     assert len(http_session_manager.session_cache) == 1
-    cache_key = generate_cache_key(f"{threading.get_ident()}:{TEST_URI}")
+    cache_key = generate_cache_key(f"{id(asyncio.get_event_loop())}:{TEST_URI}")
     session = http_session_manager.session_cache.get_cache_entry(cache_key)
     assert isinstance(session, ClientSession)
     session.post.assert_called_once_with(
@@ -391,7 +391,7 @@ async def test_session_manager_async_make_post_request(mocker, http_session_mana
     )
     assert response == "content"
     assert len(http_session_manager.session_cache) == 1
-    cache_key = generate_cache_key(f"{threading.get_ident()}:{TEST_URI}")
+    cache_key = generate_cache_key(f"{id(asyncio.get_event_loop())}:{TEST_URI}")
     session = http_session_manager.session_cache.get_cache_entry(cache_key)
     assert isinstance(session, ClientSession)
     session.post.assert_called_once_with(
@@ -431,7 +431,7 @@ async def test_session_manager_async_precached_session(http_session_manager):
 
 
 @pytest.mark.asyncio
-async def test_session_manager_async_cache_does_not_close_session_before_a_call_when_multithreading(  # noqa: E501
+async def test_async_session_manager_cache_does_not_close_session_before_call(
     http_session_manager,
 ):
     # set cache size to 1 + set future session close thread time to 0.01s
@@ -442,16 +442,13 @@ async def test_session_manager_async_cache_does_not_close_session_before_a_call_
         _session = await http_session_manager.async_cache_and_return_session(
             uri, request_timeout=ClientTimeout(_timeout_for_testing)
         )
-
         # simulate a call taking 0.01s to return a response
         await asyncio.sleep(_timeout_for_testing)
 
         assert not _session.closed
         return _session
 
-    tasks = [cache_uri_and_return_session(uri) for uri in UNIQUE_URIS]
-
-    all_sessions = await asyncio.gather(*tasks)
+    all_sessions = [await cache_uri_and_return_session(uri) for uri in UNIQUE_URIS]
     assert len(all_sessions) == len(UNIQUE_URIS)
     assert all(isinstance(s, ClientSession) for s in all_sessions)
 
@@ -485,7 +482,7 @@ async def test_session_manager_async_unique_cache_keys_created_per_thread_with_s
         event_loop = asyncio.new_event_loop()
         unique_session = event_loop.run_until_complete(
             http_session_manager.async_cache_and_return_session(
-                endpoint_uri, request_timeout=ClientTimeout(0.01)
+                endpoint_uri, request_timeout=ClientTimeout(0.1)
             )
         )
         event_loop.close()
@@ -500,6 +497,7 @@ async def test_session_manager_async_unique_cache_keys_created_per_thread_with_s
             daemon=True,
         )
         thread.start()
+        time.sleep(0.01)
         threads.append(thread)
 
     [thread.join() for thread in threads]
@@ -529,7 +527,7 @@ async def test_session_manager_async_use_new_session_if_loop_closed_for_cached_s
     )
 
     # assert session1 was cached
-    cache_key = generate_cache_key(f"{threading.get_ident()}:{TEST_URI}")
+    cache_key = generate_cache_key(f"{id(asyncio.get_event_loop())}:{TEST_URI}")
 
     assert len(http_session_manager.session_cache) == 1
     cached_session = http_session_manager.session_cache.get_cache_entry(cache_key)
@@ -569,7 +567,7 @@ async def test_session_manager_async_use_new_session_if_session_closed_for_cache
     )
 
     # assert session1 was cached
-    cache_key = generate_cache_key(f"{threading.get_ident()}:{TEST_URI}")
+    cache_key = generate_cache_key(f"{id(asyncio.get_event_loop())}:{TEST_URI}")
 
     assert len(http_session_manager.session_cache) == 1
     cached_session = http_session_manager.session_cache.get_cache_entry(cache_key)

{web3-7.11.1 → web3-7.12.1}/tests/ens/test_offchain_resolution.py

@@ -6,7 +6,7 @@ from aiohttp import (
 import requests
 
 from ens.utils import (
-    ens_encode_name,
+    dns_encode_name,
 )
 from web3.exceptions import (
     OffchainLookup,
@@ -172,14 +172,14 @@ def test_offchain_resolver_function_call_raises_with_ccip_read_disabled(
     # should fail here with `ccip_read_enabled` flag set to False
     with pytest.raises(OffchainLookup):
         offchain_resolver.functions.resolve(
-            ens_encode_name("offchainexample.eth"),
+            dns_encode_name("offchainexample.eth"),
             ENCODED_ADDR_CALLDATA,
         ).call(ccip_read_enabled=False)
 
     # pass flag on specific call via ContractCaller is also an option
     with pytest.raises(OffchainLookup):
         offchain_resolver.caller(ccip_read_enabled=False).resolve(
-            ens_encode_name("offchainexample.eth"),
+            dns_encode_name("offchainexample.eth"),
             ENCODED_ADDR_CALLDATA,
         )