web3 7.1.0__tar.gz → 7.2.0__tar.gz

{web3-7.1.0/web3.egg-info → web3-7.2.0}/PKG-INFO

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

{web3-7.1.0 → web3-7.2.0}/setup.py

@@ -51,7 +51,7 @@ with open("./README.md") as readme:
 setup(
     name="web3",
     # *IMPORTANT*: Don't manually change the version here. Use `make bump`, as described in readme
-    version="7.1.0",
+    version="7.2.0",
     description="""web3: A Python library for interacting with Ethereum""",
     long_description=long_description,
     long_description_content_type="text/markdown",

{web3-7.1.0 → web3-7.2.0}/tests/core/providers/test_async_http_provider.py

@@ -94,8 +94,8 @@ async def test_async_user_provided_session() -> None:
     assert cached_session == session
 
 
-def test_get_request_headers():
-    provider = AsyncHTTPProvider()
+@pytest.mark.parametrize("provider", (AsyncHTTPProvider(), AsyncHTTPProvider))
+def test_get_request_headers(provider):
     headers = provider.get_request_headers()
     assert len(headers) == 2
     assert headers["Content-Type"] == "application/json"

{web3-7.1.0 → web3-7.2.0}/tests/core/providers/test_http_provider.py

@@ -101,8 +101,8 @@ def test_user_provided_session():
     assert adapter._pool_maxsize == 20
 
 
-def test_get_request_headers():
-    provider = HTTPProvider()
+@pytest.mark.parametrize("provider", (HTTPProvider(), HTTPProvider))
+def test_get_request_headers(provider):
     headers = provider.get_request_headers()
     assert len(headers) == 2
     assert headers["Content-Type"] == "application/json"

web3-7.2.0/web3/_utils/http.py

@@ -0,0 +1,12 @@
+DEFAULT_HTTP_TIMEOUT = 30.0
+
+
+def construct_user_agent(
+    module: str,
+    class_name: str,
+) -> str:
+    from web3 import (
+        __version__ as web3_version,
+    )
+
+    return f"web3.py/{web3_version}/{module}.{class_name}"

{web3-7.1.0 → web3-7.2.0}/web3/_utils/module_testing/eth_module.py

@@ -88,6 +88,7 @@ from web3.exceptions import (
 )
 from web3.middleware import (
     ExtraDataToPOAMiddleware,
+    SignAndSendRawMiddlewareBuilder,
 )
 from web3.types import (
     ENS,
@@ -725,6 +726,26 @@ class AsyncEthModuleTest:
         txn_hash = await async_w3.eth.send_raw_transaction(signed.raw_transaction)
         assert txn_hash == HexBytes(signed.hash)
 
+    @pytest.mark.asyncio
+    async def test_async_sign_and_send_raw_middleware(
+        self, async_w3: "AsyncWeb3", keyfile_account_pkey: HexStr
+    ) -> None:
+        keyfile_account = async_w3.eth.account.from_key(keyfile_account_pkey)
+        txn: TxParams = {
+            "from": keyfile_account.address,
+            "to": keyfile_account.address,
+            "value": Wei(0),
+            "gas": 21000,
+        }
+        async_w3.middleware_onion.add(
+            SignAndSendRawMiddlewareBuilder.build(keyfile_account), "signing"
+        )
+        txn_hash = await async_w3.eth.send_transaction(txn)
+        assert isinstance(txn_hash, HexBytes)
+
+        # clean up
+        async_w3.middleware_onion.remove("signing")
+
     @pytest.mark.asyncio
     async def test_GasPriceStrategyMiddleware(
         self,
@@ -3716,6 +3737,25 @@ class EthModuleTest:
         txn_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
         assert txn_hash == HexBytes(signed.hash)
 
+    def test_sign_and_send_raw_middleware(
+        self, w3: "Web3", keyfile_account_pkey: HexStr
+    ) -> None:
+        keyfile_account = w3.eth.account.from_key(keyfile_account_pkey)
+        txn: TxParams = {
+            "from": keyfile_account.address,
+            "to": keyfile_account.address,
+            "value": Wei(0),
+            "gas": 21000,
+        }
+        w3.middleware_onion.add(
+            SignAndSendRawMiddlewareBuilder.build(keyfile_account), "signing"
+        )
+        txn_hash = w3.eth.send_transaction(txn)
+        assert isinstance(txn_hash, HexBytes)
+
+        # cleanup
+        w3.middleware_onion.remove("signing")
+
     def test_eth_call(self, w3: "Web3", math_contract: "Contract") -> None:
         txn_params = math_contract._prepare_transaction(
             abi_element_identifier="add",

{web3-7.1.0 → web3-7.2.0}/web3/middleware/signing.py

@@ -189,7 +189,7 @@ class SignAndSendRawMiddlewareBuilder(Web3MiddlewareBuilder):
 
                 return (
                     RPCEndpoint("eth_sendRawTransaction"),
-                    [raw_tx.hex()],
+                    [raw_tx.to_0x_hex()],
                 )
 
     # -- async -- #
@@ -220,5 +220,5 @@ class SignAndSendRawMiddlewareBuilder(Web3MiddlewareBuilder):
 
                 return (
                     RPCEndpoint("eth_sendRawTransaction"),
-                    [raw_tx.hex()],
+                    [raw_tx.to_0x_hex()],
                 )

{web3-7.1.0 → web3-7.2.0}/web3/providers/rpc/async_rpc.py

@@ -19,6 +19,7 @@ from eth_typing import (
     URI,
 )
 from eth_utils import (
+    combomethod,
     to_dict,
 )
 
@@ -108,10 +109,17 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
             yield "headers", self.get_request_headers()
         yield from self._request_kwargs.items()
 
-    def get_request_headers(self) -> Dict[str, str]:
+    @combomethod
+    def get_request_headers(cls) -> Dict[str, str]:
+        if isinstance(cls, AsyncHTTPProvider):
+            cls_name = cls.__class__.__name__
+        else:
+            cls_name = cls.__name__
+        module = cls.__module__
+
         return {
             "Content-Type": "application/json",
-            "User-Agent": construct_user_agent(type(self)),
+            "User-Agent": construct_user_agent(module, cls_name),
         }
 
     async def _make_request(self, method: RPCEndpoint, request_data: bytes) -> bytes:

{web3-7.1.0 → web3-7.2.0}/web3/providers/rpc/rpc.py

@@ -16,6 +16,7 @@ from eth_typing import (
     URI,
 )
 from eth_utils import (
+    combomethod,
     to_dict,
 )
 import requests
@@ -116,10 +117,18 @@ class HTTPProvider(JSONBaseProvider):
             yield "headers", self.get_request_headers()
         yield from self._request_kwargs.items()
 
-    def get_request_headers(self) -> Dict[str, str]:
+    @combomethod
+    def get_request_headers(cls) -> Dict[str, str]:
+        if isinstance(cls, HTTPProvider):
+            cls_name = cls.__class__.__name__
+        else:
+            cls_name = cls.__name__
+
+        module = cls.__module__
+
         return {
             "Content-Type": "application/json",
-            "User-Agent": construct_user_agent(type(self)),
+            "User-Agent": construct_user_agent(module, cls_name),
         }
 
     def _make_request(self, method: RPCEndpoint, request_data: bytes) -> bytes:

{web3-7.1.0 → web3-7.2.0/web3.egg-info}/PKG-INFO

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

{web3-7.1.0 → web3-7.2.0}/web3.egg-info/SOURCES.txt

@@ -338,11 +338,6 @@ web3/scripts/install_pre_releases.py
 web3/scripts/parse_pygeth_version.py
 web3/scripts/release/__init__.py
 web3/scripts/release/test_package.py
-web3/tools/benchmark/__init__.py
-web3/tools/benchmark/main.py
-web3/tools/benchmark/node.py
-web3/tools/benchmark/reporting.py
-web3/tools/benchmark/utils.py
 web3/utils/__init__.py
 web3/utils/abi.py
 web3/utils/address.py

web3-7.1.0/web3/_utils/http.py

@@ -1,9 +0,0 @@
-DEFAULT_HTTP_TIMEOUT = 30.0
-
-
-def construct_user_agent(class_type: type) -> str:
-    from web3 import (
-        __version__ as web3_version,
-    )
-
-    return f"web3.py/{web3_version}/{class_type.__module__}.{class_type.__qualname__}"

web3-7.1.0/web3/tools/benchmark/main.py

@@ -1,190 +0,0 @@
-import argparse
-import asyncio
-from collections import (
-    defaultdict,
-)
-import logging
-import sys
-import timeit
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Union,
-)
-
-from web3 import (
-    AsyncHTTPProvider,
-    AsyncWeb3,
-    HTTPProvider,
-    Web3,
-)
-from web3.middleware import (
-    BufferedGasEstimateMiddleware,
-    GasPriceStrategyMiddleware,
-)
-from web3.tools.benchmark.node import (
-    GethBenchmarkFixture,
-)
-from web3.tools.benchmark.reporting import (
-    print_entry,
-    print_footer,
-    print_header,
-)
-from web3.tools.benchmark.utils import (
-    wait_for_aiohttp,
-    wait_for_http,
-)
-from web3.types import (
-    Wei,
-)
-
-KEYFILE_PW = "web3py-test"
-
-parser = argparse.ArgumentParser()
-parser.add_argument(
-    "--num-calls",
-    type=int,
-    default=10,
-    help="The number of RPC calls to make",
-)
-
-# TODO - layers to test:
-# contract.functions.method(...).call()
-# w3.eth.call(...)
-# HTTPProvider.make_request(...)
-
-
-def build_web3_http(endpoint_uri: str) -> Web3:
-    wait_for_http(endpoint_uri)
-    _w3 = Web3(
-        HTTPProvider(endpoint_uri),
-        middleware=[GasPriceStrategyMiddleware, BufferedGasEstimateMiddleware],
-    )
-    return _w3
-
-
-async def build_async_w3_http(endpoint_uri: str) -> AsyncWeb3:
-    await wait_for_aiohttp(endpoint_uri)
-    _w3 = AsyncWeb3(
-        AsyncHTTPProvider(endpoint_uri),
-        middleware=[GasPriceStrategyMiddleware, BufferedGasEstimateMiddleware],
-    )
-    return _w3
-
-
-def sync_benchmark(func: Callable[..., Any], n: int) -> Union[float, str]:
-    try:
-        starttime = timeit.default_timer()
-        for _ in range(n):
-            func()
-        endtime = timeit.default_timer()
-        execution_time = endtime - starttime
-        return execution_time
-    except Exception:
-        return "N/A"
-
-
-async def async_benchmark(func: Callable[..., Any], n: int) -> Union[float, str]:
-    try:
-        starttime = timeit.default_timer()
-        for result in asyncio.as_completed([func() for _ in range(n)]):
-            await result
-        execution_time = timeit.default_timer() - starttime
-        return execution_time
-    except Exception:
-        return "N/A"
-
-
-def main(logger: logging.Logger, num_calls: int) -> None:
-    fixture = GethBenchmarkFixture()
-    for built_fixture in fixture.build():
-        for _ in built_fixture:
-            w3_http = build_web3_http(fixture.endpoint_uri)
-            try:
-                loop = asyncio.get_running_loop()
-            except RuntimeError:
-                loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(loop)
-
-            # -- sync -- #
-            account = w3_http.eth.accounts[0]
-
-            # -- async -- #
-            async_w3_http = loop.run_until_complete(
-                build_async_w3_http(fixture.endpoint_uri)
-            )
-            async_accounts = loop.run_until_complete(async_w3_http.eth.accounts)
-            async_account = async_accounts[0]
-
-            methods = [
-                {
-                    "name": "eth_gasPrice",
-                    "params": {},
-                    "exec": lambda w3_http=w3_http: w3_http.eth.gas_price,
-                    "async_exec": lambda async_w3_http=async_w3_http: async_w3_http.eth.gas_price,  # noqa: E501
-                },
-                {
-                    "name": "eth_sendTransaction",
-                    "params": {},
-                    "exec": lambda w3_http=w3_http, account=account: w3_http.eth.send_transaction(  # noqa: E501
-                        {
-                            "to": "0xd3CdA913deB6f67967B99D67aCDFa1712C293601",
-                            "from": account,
-                            "value": Wei(1),
-                        }
-                    ),
-                    "async_exec": lambda async_w3_http=async_w3_http, async_account=async_account: async_w3_http.eth.send_transaction(  # noqa: E501
-                        {
-                            "to": "0xd3CdA913deB6f67967B99D67aCDFa1712C293601",
-                            "from": async_account,
-                            "value": Wei(1),
-                        }
-                    ),
-                },
-                {
-                    "name": "eth_blockNumber",
-                    "params": {},
-                    "exec": lambda w3_http=w3_http: w3_http.eth.block_number,
-                    "async_exec": lambda async_w3_http=async_w3_http: async_w3_http.eth.block_number,  # noqa: E501
-                },
-                {
-                    "name": "eth_getBlock",
-                    "params": {},
-                    "exec": lambda w3_http=w3_http: w3_http.eth.get_block(1),
-                    "async_exec": lambda async_w3_http=async_w3_http: async_w3_http.eth.get_block(  # noqa: E501
-                        1
-                    ),
-                },
-            ]
-
-            def benchmark(
-                method: Dict[str, Any], loop: asyncio.AbstractEventLoop = loop
-            ) -> None:
-                outcomes: Dict[str, Union[str, float]] = defaultdict(lambda: "N/A")
-                outcomes["name"] = method["name"]
-                outcomes["HTTPProvider"] = sync_benchmark(
-                    method["exec"],
-                    num_calls,
-                )
-                outcomes["AsyncHTTPProvider"] = loop.run_until_complete(
-                    async_benchmark(method["async_exec"], num_calls)
-                )
-                print_entry(logger, outcomes)
-
-            print_header(logger, num_calls)
-
-            for method in methods:
-                benchmark(method)
-
-            print_footer(logger)
-
-
-if __name__ == "__main__":
-    args = parser.parse_args()
-
-    logger = logging.getLogger()
-    logger.setLevel(logging.INFO)
-    logger.addHandler(logging.StreamHandler(sys.stdout))
-
-    main(logger, args.num_calls)

web3-7.1.0/web3/tools/benchmark/node.py

@@ -1,120 +0,0 @@
-import os
-import socket
-from subprocess import (
-    PIPE,
-    Popen,
-    check_output,
-)
-from tempfile import (
-    TemporaryDirectory,
-)
-from typing import (
-    Any,
-    Generator,
-    Sequence,
-)
-import zipfile
-
-from geth.install import (
-    get_executable_path,
-    install_geth,
-)
-
-from web3.tools.benchmark.utils import (
-    kill_proc_gracefully,
-)
-
-GETH_FIXTURE_ZIP = "geth-1.14.5-fixture.zip"
-
-
-class GethBenchmarkFixture:
-    def __init__(self) -> None:
-        self.rpc_port = self._rpc_port()
-        self.endpoint_uri = self._endpoint_uri()
-        self.geth_binary = self._geth_binary()
-
-    def build(self) -> Generator[Any, None, None]:
-        with TemporaryDirectory() as base_dir:
-            zipfile_path = os.path.abspath(
-                os.path.join(
-                    os.path.dirname(__file__),
-                    "../../../tests/integration/",
-                    GETH_FIXTURE_ZIP,
-                )
-            )
-            tmp_datadir = os.path.join(str(base_dir), "datadir")
-            with zipfile.ZipFile(zipfile_path, "r") as zip_ref:
-                zip_ref.extractall(tmp_datadir)
-            self.datadir = tmp_datadir
-
-            genesis_file = os.path.join(self.datadir, "genesis.json")
-
-            yield self._geth_process(self.datadir, genesis_file, self.rpc_port)
-
-    def _rpc_port(self) -> str:
-        sock = socket.socket()
-        sock.bind(("127.0.0.1", 0))
-        port = sock.getsockname()[1]
-        sock.close()
-        return str(port)
-
-    def _endpoint_uri(self) -> str:
-        return f"http://localhost:{self.rpc_port}"
-
-    def _geth_binary(self) -> str:
-        if "GETH_BINARY" in os.environ:
-            return os.environ["GETH_BINARY"]
-        elif "GETH_VERSION" in os.environ:
-            geth_version = os.environ["GETH_VERSION"]
-            _geth_binary = get_executable_path(geth_version)
-            if not os.path.exists(_geth_binary):
-                install_geth(geth_version)
-            assert os.path.exists(_geth_binary)
-            return _geth_binary
-        else:
-            return "geth"
-
-    def _geth_command_arguments(self, datadir: str) -> Sequence[str]:
-        return (
-            self.geth_binary,
-            "--dev",
-            "--dev.period",
-            "100",
-            "--datadir",
-            datadir,
-            "--nodiscover",
-            "--http",
-            "--http.port",
-            self.rpc_port,
-            "--http.api",
-            "admin,eth,net,web3",
-            "--ipcdisable",
-            "--password",
-            os.path.join(datadir, "keystore", "pw.txt"),
-        )
-
-    def _geth_process(
-        self, datadir: str, genesis_file: str, rpc_port: str
-    ) -> Generator[Any, None, None]:
-        init_datadir_command = (
-            self.geth_binary,
-            "--datadir",
-            str(datadir),
-            "init",
-            str(genesis_file),
-        )
-        check_output(
-            init_datadir_command,
-            stdin=PIPE,
-            stderr=PIPE,
-        )
-        proc = Popen(
-            self._geth_command_arguments(datadir),
-            stdin=PIPE,
-            stdout=PIPE,
-            stderr=PIPE,
-        )
-        try:
-            yield proc
-        finally:
-            kill_proc_gracefully(proc)

web3-7.1.0/web3/tools/benchmark/reporting.py

@@ -1,39 +0,0 @@
-from logging import (
-    Logger,
-)
-from typing import (
-    Any,
-    Dict,
-)
-
-
-def print_header(logger: Logger, num_calls: int) -> None:
-    logger.info(
-        "|{:^26}|{:^20}|{:^20}|{:^20}|{:^20}|".format(
-            f"Method ({num_calls} calls)",
-            "HTTPProvider",
-            "AsyncHTTProvider",
-            "IPCProvider",
-            "WebSocketProvider",
-        )
-    )
-    logger.info("-" * 112)
-
-
-def print_entry(
-    logger: Logger,
-    method_benchmarks: Dict[str, Any],
-) -> None:
-    logger.info(
-        "|{:^26}|{:^20.10}|{:^20.10}|{:^20.10}|{:^20.10}|".format(
-            method_benchmarks["name"],
-            method_benchmarks["HTTPProvider"],
-            method_benchmarks["AsyncHTTPProvider"],
-            method_benchmarks["IPCProvider"],
-            method_benchmarks["WebSocketProvider"],
-        )
-    )
-
-
-def print_footer(logger: Logger) -> None:
-    logger.info("-" * 112)

web3-7.1.0/web3/tools/benchmark/utils.py

@@ -1,69 +0,0 @@
-import asyncio
-import signal
-import socket
-import time
-from typing import (
-    Any,
-)
-
-import aiohttp
-import requests
-
-
-def wait_for_socket(ipc_path: str, timeout: int = 30) -> None:
-    start = time.time()
-    while time.time() < start + timeout:
-        try:
-            sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-            sock.connect(ipc_path)
-            sock.settimeout(timeout)
-        except OSError:
-            time.sleep(0.01)
-        else:
-            break
-
-
-def wait_for_http(endpoint_uri: str, timeout: int = 60) -> None:
-    start = time.time()
-    while time.time() < start + timeout:
-        try:
-            requests.get(endpoint_uri)
-        except requests.ConnectionError:
-            time.sleep(0.01)
-        else:
-            break
-
-
-async def wait_for_aiohttp(endpoint_uri: str, timeout: int = 60) -> None:
-    start = time.time()
-    while time.time() < start + timeout:
-        try:
-            async with aiohttp.ClientSession() as session:
-                await session.get(endpoint_uri)
-        except aiohttp.client_exceptions.ClientConnectorError:
-            await asyncio.sleep(0.01)
-        else:
-            break
-
-
-def wait_for_popen(proc: Any, timeout: int) -> None:
-    start = time.time()
-    while time.time() < start + timeout:
-        if proc.poll() is None:
-            time.sleep(0.01)
-        else:
-            break
-
-
-def kill_proc_gracefully(proc: Any) -> None:
-    if proc.poll() is None:
-        proc.send_signal(signal.SIGINT)
-        wait_for_popen(proc, 13)
-
-    if proc.poll() is None:
-        proc.terminate()
-        wait_for_popen(proc, 5)
-
-    if proc.poll() is None:
-        proc.kill()
-        wait_for_popen(proc, 2)