web3 7.13.0__tar.gz → 7.14.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: web3
-Version: 7.13.0
+Version: 7.14.1
 Summary: web3: A Python library for interacting with Ethereum
 Home-page: https://github.com/ethereum/web3.py
 Author: The Ethereum Foundation
@@ -37,7 +37,7 @@ Requires-Dist: websockets<16.0.0,>=10.0.0
 Requires-Dist: pyunormalize>=15.0.0
 Provides-Extra: tester
 Requires-Dist: eth-tester[py-evm]<0.14.0b1,>=0.13.0b1; extra == "tester"
-Requires-Dist: py-geth>=5.1.0; extra == "tester"
+Requires-Dist: py-geth>=6.4.0; extra == "tester"
 Provides-Extra: dev
 Requires-Dist: build>=0.9.0; extra == "dev"
 Requires-Dist: bump_my_version>=0.19.0; extra == "dev"
@@ -60,7 +60,7 @@ Requires-Dist: tox>=4.0.0; extra == "dev"
 Requires-Dist: mypy==1.10.0; extra == "dev"
 Requires-Dist: pre-commit>=3.4.0; extra == "dev"
 Requires-Dist: eth-tester[py-evm]<0.14.0b1,>=0.13.0b1; extra == "dev"
-Requires-Dist: py-geth>=5.1.0; extra == "dev"
+Requires-Dist: py-geth>=6.4.0; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: sphinx>=6.0.0; extra == "docs"
 Requires-Dist: sphinx-autobuild>=2021.3.14; extra == "docs"
@@ -77,7 +77,7 @@ Requires-Dist: tox>=4.0.0; extra == "test"
 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"
+Requires-Dist: py-geth>=6.4.0; extra == "test"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{web3-7.13.0 → web3-7.14.1}/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.1}/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.1}/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.1}/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
@@ -33,6 +33,10 @@ warn_return_any = false
 warn_unused_configs = true
 warn_unused_ignores = true
 
+[[tool.mypy.overrides]]
+module = "sphinx.*"
+follow_imports = "skip"
+
 [tool.pydocstyle]
 # All error codes found here:
 # http://www.pydocstyle.org/en/3.0.0/error_codes.html
@@ -127,7 +131,7 @@ name = "Removals"
 showcontent = true
 
 [tool.bumpversion]
-current_version = "7.13.0"
+current_version = "7.14.1"
 parse = """
     (?P<major>\\d+)
     \\.(?P<minor>\\d+)

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

@@ -9,7 +9,7 @@ extras_require = {
         # Note: ethereum-maintained libraries in this list should be added to the
         # `install_pre_releases.py` script.
         "eth-tester[py-evm]>=0.13.0b1,<0.14.0b1",
-        "py-geth>=5.1.0",
+        "py-geth>=6.4.0",
     ],
     "dev": [
         "build>=0.9.0",
@@ -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.1",
     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.1}/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.1}/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(
@@ -1334,8 +1334,7 @@ async def async_mismatched_math_contract(
     return _mismatched_math_contract
 
 
-@pytest.fixture
-@pytest.mark.asyncio
+@pytest_asyncio.fixture
 async def test_async_deploy_raises_due_to_strict_byte_checking_by_default(
     async_w3, async_bytes_contract_factory, address_conversion_func
 ):
@@ -1503,7 +1502,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.1}/tests/core/providers/test_http_provider.py

@@ -1,4 +1,6 @@
 import pytest
+import concurrent.futures
+import threading
 from unittest.mock import (
     Mock,
     patch,
@@ -133,3 +135,93 @@ def test_http_empty_batch_response(mock_post):
 
     # assert that even though there was an error, we have reset the batching state
     assert not w3.provider._is_batching
+
+
+def test_user_provided_session_shared_across_threads():
+    """
+    Test that when a user provides an explicit session to HTTPProvider,
+    that same session is used by ALL threads, not just the creating thread.
+
+    This is a regression test for:
+    https://github.com/ethereum/web3.py/issues/3789
+    """
+    shared_session = Session()
+    provider = HTTPProvider(endpoint_uri=URI, session=shared_session)
+
+    sessions_from_threads = []
+    errors = []
+
+    def get_session_from_thread():
+        try:
+            # This simulates what happens internally when a request is made
+            # from a different thread - it calls cache_and_return_session
+            session = provider._request_session_manager.cache_and_return_session(URI)
+            sessions_from_threads.append(session)
+        except Exception as e:
+            errors.append(e)
+
+    # Get session from main thread
+    main_thread_session = provider._request_session_manager.cache_and_return_session(
+        URI
+    )
+
+    # Get session from multiple different threads
+    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
+        futures = [executor.submit(get_session_from_thread) for _ in range(10)]
+        concurrent.futures.wait(futures)
+
+    assert not errors, f"Errors occurred: {errors}"
+    assert len(sessions_from_threads) == 10
+
+    # The main assertion: ALL sessions should be the SAME shared session
+    assert main_thread_session is shared_session
+    for session in sessions_from_threads:
+        assert session is shared_session, (
+            "Session from different thread should be the same as the "
+            "explicitly provided session"
+        )
+
+
+def test_no_explicit_session_creates_per_thread_sessions():
+    """
+    Test that when no explicit session is provided, each thread gets its own
+    session (the original thread-isolated behavior).
+    """
+    provider = HTTPProvider(endpoint_uri=URI)
+
+    sessions_from_threads = []
+
+    def get_session_from_thread():
+        session = provider._request_session_manager.cache_and_return_session(URI)
+        sessions_from_threads.append((threading.get_ident(), session))
+
+    # Get session from main thread
+    main_thread_id = threading.get_ident()
+    main_thread_session = provider._request_session_manager.cache_and_return_session(
+        URI
+    )
+
+    # Get sessions from different threads
+    with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
+        futures = [executor.submit(get_session_from_thread) for _ in range(3)]
+        concurrent.futures.wait(futures)
+
+    # Group sessions by thread ID
+    sessions_by_thread = {}
+    for thread_id, session in sessions_from_threads:
+        if thread_id not in sessions_by_thread:
+            sessions_by_thread[thread_id] = []
+        sessions_by_thread[thread_id].append(session)
+
+    # Verify thread isolation: same thread always gets the same session
+    for _, sessions in sessions_by_thread.items():
+        assert all(
+            s is sessions[0] for s in sessions
+        ), "Same thread should always get the same session"
+
+    # Verify different threads get different sessions (not the main thread's)
+    for thread_id, sessions in sessions_by_thread.items():
+        if thread_id != main_thread_id:
+            assert (
+                sessions[0] is not main_thread_session
+            ), "Different threads should have different sessions"

{web3-7.13.0 → web3-7.14.1}/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.1}/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.1}/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.1}/tests/integration/go_ethereum/conftest.py

@@ -35,7 +35,7 @@ from .utils import (
 )
 
 KEYFILE_PW = "web3py-test"
-GETH_FIXTURE_ZIP = "geth-1.16.2-fixture.zip"
+GETH_FIXTURE_ZIP = "geth-1.16.7-fixture.zip"
 
 
 @pytest.fixture
@@ -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.1}/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.1}/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.1}/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.1}/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.1}/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.1}/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.1}/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}")
 

{web3-7.13.0 → web3-7.14.1}/web3/_utils/http_session_manager.py

@@ -50,9 +50,11 @@ class HTTPSessionManager:
         self,
         cache_size: int = 100,
         session_pool_max_workers: int = 5,
+        explicit_session: Optional[requests.Session] = None,
     ) -> None:
         self.session_cache = SimpleCache(cache_size)
         self.session_pool = ThreadPoolExecutor(max_workers=session_pool_max_workers)
+        self._explicit_session = explicit_session
 
     @staticmethod
     def get_default_http_endpoint() -> URI:
@@ -64,6 +66,11 @@ class HTTPSessionManager:
         session: requests.Session = None,
         request_timeout: Optional[float] = None,
     ) -> requests.Session:
+        # If an explicit session was provided at init time, always use it
+        # regardless of which thread is making the request
+        if self._explicit_session is not None:
+            return self._explicit_session
+
         # cache key should have a unique thread identifier
         cache_key = generate_cache_key(f"{threading.get_ident()}:{endpoint_uri}")