web3 7.12.1__tar.gz → 7.14.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: web3
-Version: 7.12.1
+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.12.1 → 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.12.1 → 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.12.1 → 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.12.1 → 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.12.1"
+current_version = "7.14.0"
 parse = """
     (?P<major>\\d+)
     \\.(?P<minor>\\d+)

{web3-7.12.1 → 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.12.1",
+    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.12.1 → 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.12.1 → 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.14.0/tests/core/middleware/test_formatting_middleware.py

@@ -0,0 +1,236 @@
+import pytest
+from unittest.mock import (
+    Mock,
+)
+
+import pytest_asyncio
+
+from web3 import (
+    AsyncBaseProvider,
+    AsyncWeb3,
+    Web3,
+)
+from web3.exceptions import (
+    BadResponseFormat,
+    Web3RPCError,
+)
+from web3.middleware import (
+    FormattingMiddlewareBuilder,
+)
+from web3.providers.base import (
+    BaseProvider,
+)
+from web3.types import (
+    RPCEndpoint,
+)
+
+
+class DummyProvider(BaseProvider):
+    def make_request(self, method, params):
+        raise NotImplementedError(f"Cannot make request for {method}:{params}")
+
+
+@pytest.fixture
+def w3():
+    return Web3(provider=DummyProvider(), middleware=[])
+
+
+def test_formatting_middleware(w3, request_mocker):
+    # No formatters by default
+    expected = "done"
+    with request_mocker(w3, mock_results={"test_endpoint": "done"}):
+        actual = w3.manager.request_blocking(RPCEndpoint("test_endpoint"), [])
+        assert actual == expected
+
+
+def test_formatting_middleware_no_method(w3):
+    w3.middleware_onion.add(FormattingMiddlewareBuilder.build())
+
+    # Formatting middleware requires an endpoint
+    with pytest.raises(NotImplementedError):
+        w3.manager.request_blocking("test_endpoint", [])
+
+
+def test_formatting_middleware_request_formatters(w3, request_mocker):
+    callable_mock = Mock()
+    w3.middleware_onion.add(
+        FormattingMiddlewareBuilder.build(
+            request_formatters={"test_endpoint": callable_mock}
+        )
+    )
+
+    expected = "done"
+    with request_mocker(w3, mock_results={"test_endpoint": "done"}):
+        actual = w3.manager.request_blocking("test_endpoint", ["param1"])
+
+    callable_mock.assert_called_once_with(["param1"])
+    assert actual == expected
+
+
+def test_formatting_middleware_result_formatters(w3, request_mocker):
+    w3.middleware_onion.add(
+        FormattingMiddlewareBuilder.build(
+            result_formatters={"test_endpoint": lambda x: f"STATUS: {x}"}
+        )
+    )
+
+    expected = "STATUS: done"
+    with request_mocker(w3, mock_results={"test_endpoint": "done"}):
+        actual = w3.manager.request_blocking("test_endpoint", [])
+
+    assert actual == expected
+
+
+def test_formatting_middleware_result_formatters_for_none(w3, request_mocker):
+    w3.middleware_onion.add(
+        FormattingMiddlewareBuilder.build(
+            result_formatters={"test_endpoint": lambda x: hex(x)}
+        )
+    )
+
+    expected = None
+    with request_mocker(w3, mock_results={"test_endpoint": expected}):
+        actual = w3.manager.request_blocking("test_endpoint", [])
+    assert actual == expected
+
+
+def test_formatting_middleware_error_formatters(w3, request_mocker):
+    w3.middleware_onion.add(
+        FormattingMiddlewareBuilder.build(
+            result_formatters={"test_endpoint": lambda x: f"STATUS: {x}"}
+        )
+    )
+
+    expected = "error"
+    with request_mocker(w3, mock_errors={"test_endpoint": {"message": "error"}}):
+        with pytest.raises(Web3RPCError) as err:
+            w3.manager.request_blocking("test_endpoint", [])
+            assert str(err.value) == expected
+
+
+def test_formatting_middleware_raises_for_non_dict_responses(w3, request_mocker):
+    w3.middleware_onion.add(
+        FormattingMiddlewareBuilder.build(
+            result_formatters={"test_endpoint": lambda x: x}
+        )
+    )
+    w3.provider.make_request = lambda *_: "a string"
+
+    with pytest.raises(
+        BadResponseFormat,
+        match=r"Malformed response: expected a valid JSON-RPC response object, "
+        r"got: `a string`",
+    ):
+        _ = w3.eth.chain_id
+
+
+# -- async -- #
+
+
+@pytest_asyncio.fixture
+async def async_w3():
+    return AsyncWeb3(provider=AsyncBaseProvider(), middleware=[])
+
+
+@pytest.mark.asyncio
+async def test_async_formatting_middleware(async_w3, request_mocker):
+    # No formatters by default
+    expected = "done"
+    async with request_mocker(async_w3, mock_results={"test_endpoint": "done"}):
+        actual = await async_w3.manager.coro_request(RPCEndpoint("test_endpoint"), [])
+        assert actual == expected
+
+
+@pytest.mark.asyncio
+async def test_async_formatting_middleware_no_method(async_w3):
+    async_w3.middleware_onion.add(FormattingMiddlewareBuilder.build())
+
+    # Formatting middleware requires an endpoint
+    with pytest.raises(NotImplementedError):
+        await async_w3.manager.coro_request("test_endpoint", [])
+
+
+@pytest.mark.asyncio
+async def test_async_formatting_middleware_request_formatters(async_w3, request_mocker):
+    callable_mock = Mock()
+    async_w3.middleware_onion.add(
+        FormattingMiddlewareBuilder.build(
+            request_formatters={"test_endpoint": callable_mock}
+        )
+    )
+
+    expected = "done"
+    async with request_mocker(async_w3, mock_results={"test_endpoint": "done"}):
+        actual = await async_w3.manager.coro_request("test_endpoint", ["param1"])
+
+    callable_mock.assert_called_once_with(["param1"])
+    assert actual == expected
+
+
+@pytest.mark.asyncio
+async def test_async_formatting_middleware_result_formatters(async_w3, request_mocker):
+    async_w3.middleware_onion.add(
+        FormattingMiddlewareBuilder.build(
+            result_formatters={"test_endpoint": lambda x: f"STATUS: {x}"}
+        )
+    )
+
+    expected = "STATUS: done"
+    async with request_mocker(async_w3, mock_results={"test_endpoint": "done"}):
+        actual = await async_w3.manager.coro_request("test_endpoint", [])
+
+    assert actual == expected
+
+
+@pytest.mark.asyncio
+async def test_async_formatting_middleware_result_formatters_for_none(
+    async_w3, request_mocker
+):
+    async_w3.middleware_onion.add(
+        FormattingMiddlewareBuilder.build(
+            result_formatters={"test_endpoint": lambda x: hex(x)}
+        )
+    )
+
+    expected = None
+    async with request_mocker(async_w3, mock_results={"test_endpoint": expected}):
+        actual = await async_w3.manager.coro_request("test_endpoint", [])
+    assert actual == expected
+
+
+@pytest.mark.asyncio
+async def test_async_formatting_middleware_error_formatters(async_w3, request_mocker):
+    async_w3.middleware_onion.add(
+        FormattingMiddlewareBuilder.build(
+            result_formatters={"test_endpoint": lambda x: f"STATUS: {x}"}
+        )
+    )
+
+    expected = "error"
+    async with request_mocker(
+        async_w3, mock_errors={"test_endpoint": {"message": "error"}}
+    ):
+        with pytest.raises(Web3RPCError) as err:
+            await async_w3.manager.coro_request("test_endpoint", [])
+            assert str(err.value) == expected
+
+
+@pytest.mark.asyncio
+async def test_async_formatting_middleware_raises_for_non_dict_responses(async_w3):
+    async_w3.middleware_onion.add(
+        FormattingMiddlewareBuilder.build(
+            result_formatters={"test_endpoint": lambda x: x}
+        )
+    )
+
+    async def _make_request(*_):
+        return "a string"
+
+    async_w3.provider.make_request = _make_request
+
+    with pytest.raises(
+        BadResponseFormat,
+        match=r"Malformed response: expected a valid JSON-RPC response object, "
+        r"got: `a string`",
+    ):
+        _ = await async_w3.eth.chain_id