web3 7.1.0__py3-none-any.whl → 7.2.0__py3-none-any.whl

web3/_utils/http.py

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

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/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/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/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.dist-info → web3-7.2.0.dist-info}/METADATA

@@ -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.dist-info → web3-7.2.0.dist-info}/RECORD

@@ -45,7 +45,7 @@ web3/_utils/events.py,sha256=sVAXWUMmWKwYguWzk_jqra3rI6NZ55T3XfDp4_aDa-8,17044
 web3/_utils/fee_utils.py,sha256=MFt27R9E3qFP-Hf87-Lzv0JAiuYRE_qqafyTmzctAYA,2145
 web3/_utils/filters.py,sha256=1WX2Vgmat8QKj0WNm_GoRcVp4iJ0BhaIpM_RbcZlBzs,11860
 web3/_utils/formatters.py,sha256=RfRZU0aXC99s6OoLMY7D-fcYJyVAYBEwdbw-JIDjbZE,3067
-web3/_utils/http.py,sha256=NNcbf_K814Ggpt0YiGTWjV3CCUrLkpZpQDru4f-3C9E,235
+web3/_utils/http.py,sha256=2R3UOeZmwiQGc3ladf78R9AnufbGaTXAntqf-ZQlZPI,230
 web3/_utils/http_session_manager.py,sha256=Q5K9qJVOAjpO6490McC5kdO4lgjt-c-zxkp0kyDY2pI,11520
 web3/_utils/hypothesis.py,sha256=4Cm4iOWv-uP9irg_Pv63kYNDYUAGhnUH6fOPWRw3A0g,209
 web3/_utils/math.py,sha256=4oU5YdbQBXElxK00CxmUZ94ApXFu9QT_TrO0Kho1HTs,1083
@@ -86,7 +86,7 @@ web3/_utils/contract_sources/contract_data/storage_contract.py,sha256=vP1Qaekjld
 web3/_utils/contract_sources/contract_data/string_contract.py,sha256=y6EFnum4zDrrRUmuXExCGr2bhZMrerbMiqJiamUU2Tw,11210
 web3/_utils/contract_sources/contract_data/tuple_contracts.py,sha256=QuqPfv3BxjqDjeLScnxJDEPtPZMAB4jwHxsAOeVd6kk,23176
 web3/_utils/module_testing/__init__.py,sha256=tPFAaX7xOR50CPTq24UeY-1CX1LQxxmEOPr0-tIRkoE,376
-web3/_utils/module_testing/eth_module.py,sha256=gX-7yDry-fcz1UtOI3_DQQKFSnwrA1dKuBaEJTGdjrE,186255
+web3/_utils/module_testing/eth_module.py,sha256=0Ke5-Ayh2MJuzT8-zL3jlUy4WbHvE7nYi2fBM__FcmM,187661
 web3/_utils/module_testing/go_ethereum_admin_module.py,sha256=_c-6SyzZkfAJ-7ySXUpw9FEr4cg-ShRdAGSAHWanCtY,3406
 web3/_utils/module_testing/go_ethereum_txpool_module.py,sha256=5f8XL8-2x3keyGRaITxMQYl9oQzjgqGn8zobB-j9BPs,1176
 web3/_utils/module_testing/module_testing_utils.py,sha256=koDvLoR5q8wFOz_8o9oRpEpjbuvU8cUbBe1PM39LjG0,7304
@@ -122,7 +122,7 @@ web3/middleware/gas_price_strategy.py,sha256=ZjZ6pe3z0mDGLZHYoFXp4_fZIePqukljEh9
 web3/middleware/names.py,sha256=OBpsvCmcTItth4TcvUNUvcYmINnudtCHq3n6YO_BkNs,4309
 web3/middleware/proof_of_authority.py,sha256=0AT4jr5CmTdrvl8Jiy-WYy8IFDYBOEaesgHDwpn0c7M,1429
 web3/middleware/pythonic.py,sha256=awc8I6lLzVc2Iv138sps2uf6dMQipskLRBTdvTEEIgQ,348
-web3/middleware/signing.py,sha256=O5kOY6xcCjms7W57H53nYJ22N47TZrO-hnd3Lx2ThHs,5887
+web3/middleware/signing.py,sha256=1DOYxpmCra-Qq5r42237q3b54uDO-QHjMVMulxVpLVQ,5899
 web3/middleware/stalecheck.py,sha256=oWRA69BGIbNGjHSnUVOBnoxOYJZYjzRzlqqL5RRlnzk,2680
 web3/middleware/validation.py,sha256=QxActrJk_zsXXiwpadP2MUjZBS5E50OJOtUwVrm9XVo,4280
 web3/providers/__init__.py,sha256=YkcSzE9AubvSp-UfvJjyCrdepvziysbqeq2LT0ImDoc,936
@@ -143,27 +143,22 @@ web3/providers/persistent/request_processor.py,sha256=E1jJwsvrPBTbufCy2LeNvMdRXf
 web3/providers/persistent/utils.py,sha256=gfY7w1HB8xuE7OujSrbwWYjQuQ8nzRBoxoL8ESinqWM,1140
 web3/providers/persistent/websocket.py,sha256=2EuBOdkEBTp6ge53UlJbjV0eAUJ143TkmqrOLTQl9kk,4231
 web3/providers/rpc/__init__.py,sha256=mObsuwjr7xyHnnRlwzsmbp2JgZdn2NXSSctvpye4AuQ,149
-web3/providers/rpc/async_rpc.py,sha256=hibsCoyrAD199ExAEyHRsEnZ0_rDP_2EC2k5g-D2zhw,5609
-web3/providers/rpc/rpc.py,sha256=ePlGdlkvQTaf2Wi2khxiY-rRj-OFcPlpDMuTPLKaAyU,5655
+web3/providers/rpc/async_rpc.py,sha256=fRZh36q735OI7HFt_QsueFC4zgSSkm3MsYMh9C4b3ds,5824
+web3/providers/rpc/rpc.py,sha256=9_ju2UZX3Ew2HhmyRWnXGhRW9NTvW0roFQ9BI2JzuI0,5866
 web3/providers/rpc/utils.py,sha256=_mtoZMMIoZpPA8J8U5DfRxaNQmi8bw0ZVUiqn1Nz4co,2154
 web3/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 web3/scripts/install_pre_releases.py,sha256=uVxsZk239640yxiqlPhfXxZKSsh3858pURKppi9kM5U,821
 web3/scripts/parse_pygeth_version.py,sha256=BZjWOsJmYuFbAnFuB1jec9Rl6z0tJJNFFV38sJvDfGo,416
 web3/scripts/release/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 web3/scripts/release/test_package.py,sha256=DH0AryllcF4zfpWSd0NLPSQGHNoC-Qng5WYYbS5_4c8,1534
-web3/tools/benchmark/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-web3/tools/benchmark/main.py,sha256=9nBC8yvdiNPoRuNlcqKC6HKWly_iwOYSeG0cOQCjfpg,5810
-web3/tools/benchmark/node.py,sha256=n73GckmBKLm4_urC7HfF_Z3ZURffNMjq6ymzb9HM9c8,3252
-web3/tools/benchmark/reporting.py,sha256=G2bj_Eo2kBV06GARDYK9zr0VqesiR0_5JLKvhAo6zRM,912
-web3/tools/benchmark/utils.py,sha256=7OOdUD71AVWi0cowAE9ekMgqlfcJwk3vrNnMCHtiGdU,1696
 web3/utils/__init__.py,sha256=XwpyVR4EBkfqV5SHBH3maNyNBy624EwqujRgetLc7PU,1781
 web3/utils/abi.py,sha256=iSBaCW41UxB1q1UHDPwJ1QJbdiuYmTWNu8m6E28DqlY,18672
 web3/utils/address.py,sha256=KC_IpEbixSCuMhaW6V2QCyyJTYKYGS9c8QtI9_aH7zQ,967
 web3/utils/async_exception_handling.py,sha256=GZWSBFC0-Wmwz1tpTie-1AKRbIQH7JkmBpf5bXrUTzY,3320
 web3/utils/caching.py,sha256=IG_IxW-jyiRklrIyUgjOj3GQvcXrok0KLDX3ch_6wuA,2390
 web3/utils/exception_handling.py,sha256=k31JROfUyKIm9PoEWOtYSkIq9wL8SOBwQfnSLNQyfnM,3097
-web3-7.1.0.dist-info/LICENSE,sha256=ScEyLx1vWrB0ybKiZKKTXm5QhVksHCEUtTp4lwYV45I,1095
-web3-7.1.0.dist-info/METADATA,sha256=p_1iA6mObqMRYbT9SN-0xI9fr_Wh-AN6-fZcOknn1BU,4986
-web3-7.1.0.dist-info/WHEEL,sha256=UvcQYKBHoFqaQd6LKyqHw9fxEolWLQnlzP0h_LgJAfI,91
-web3-7.1.0.dist-info/top_level.txt,sha256=iwupuJh7wgypXrpk_awszyri3TahRr5vxSphNyvt1bU,9
-web3-7.1.0.dist-info/RECORD,,
+web3-7.2.0.dist-info/LICENSE,sha256=ScEyLx1vWrB0ybKiZKKTXm5QhVksHCEUtTp4lwYV45I,1095
+web3-7.2.0.dist-info/METADATA,sha256=gKCHrOjfTAYhnhPMuMatLqkhL2cBlKrpnHuuPsWOaUo,4986
+web3-7.2.0.dist-info/WHEEL,sha256=UvcQYKBHoFqaQd6LKyqHw9fxEolWLQnlzP0h_LgJAfI,91
+web3-7.2.0.dist-info/top_level.txt,sha256=iwupuJh7wgypXrpk_awszyri3TahRr5vxSphNyvt1bU,9
+web3-7.2.0.dist-info/RECORD,,

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/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/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/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)