web3 7.0.0b1__py3-none-any.whl → 7.7.0__py3-none-any.whl

web3/tools/benchmark/main.py

@@ -1,185 +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),
-        middlewares=[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),
-        middlewares=[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 -- #
-            coinbase = w3_http.eth.coinbase
-
-            # -- async -- #
-            async_w3_http = loop.run_until_complete(
-                build_async_w3_http(fixture.endpoint_uri)
-            )
-            async_coinbase = loop.run_until_complete(async_w3_http.eth.coinbase)
-
-            methods = [
-                {
-                    "name": "eth_gasPrice",
-                    "params": {},
-                    "exec": lambda: w3_http.eth.gas_price,
-                    "async_exec": lambda: async_w3_http.eth.gas_price,
-                },
-                {
-                    "name": "eth_sendTransaction",
-                    "params": {},
-                    "exec": lambda: w3_http.eth.send_transaction(
-                        {
-                            "to": "0xd3CdA913deB6f67967B99D67aCDFa1712C293601",
-                            "from": coinbase,
-                            "value": Wei(1),
-                        }
-                    ),
-                    "async_exec": lambda: async_w3_http.eth.send_transaction(
-                        {
-                            "to": "0xd3CdA913deB6f67967B99D67aCDFa1712C293601",
-                            "from": async_coinbase,
-                            "value": Wei(1),
-                        }
-                    ),
-                },
-                {
-                    "name": "eth_blockNumber",
-                    "params": {},
-                    "exec": lambda: w3_http.eth.block_number,
-                    "async_exec": lambda: async_w3_http.eth.block_number,
-                },
-                {
-                    "name": "eth_getBlock",
-                    "params": {},
-                    "exec": lambda: w3_http.eth.get_block(1),
-                    "async_exec": lambda: async_w3_http.eth.get_block(1),
-                },
-            ]
-
-            def benchmark(method: Dict[str, Any]) -> 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,126 +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.13.11-fixture.zip"
-
-# use same coinbase value as in `web3.py/tests/integration/generate_fixtures/common.py`
-COINBASE = "0xdc544d1aa88ff8bbd2f2aec754b1f1e99e1812fd"
-
-
-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",
-            str(datadir),
-            "--nodiscover",
-            "--http",
-            "--http.port",
-            self.rpc_port,
-            "--http.api",
-            "admin,eth,net,web3",
-            "--ipcdisable",
-            "--allow-insecure-unlock",
-            "--miner.etherbase",
-            COINBASE[2:],
-            "--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 (FileNotFoundError, socket.error):
-            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)

web3/tools/pytest_ethereum/_utils.py

@@ -1,145 +0,0 @@
-from typing import (
-    Any,
-    Dict,
-    Iterable,
-    List,
-    Tuple,
-)
-
-from eth_typing import (
-    URI,
-    Address,
-    ContractName,
-    Manifest,
-)
-from eth_utils import (
-    to_dict,
-    to_hex,
-    to_list,
-)
-from eth_utils.toolz import (
-    assoc,
-    assoc_in,
-    dissoc,
-)
-
-from ethpm import (
-    Package,
-)
-from ethpm.uri import (
-    check_if_chain_matches_chain_uri,
-)
-from web3 import (
-    Web3,
-)
-from web3.tools.pytest_ethereum.exceptions import (
-    LinkerError,
-)
-from web3.types import (
-    TxReceipt,
-)
-
-
-def pluck_matching_uri(deployment_data: Dict[URI, Dict[str, str]], w3: Web3) -> URI:
-    """
-    Return any blockchain uri that matches w3-connected chain, if one
-    is present in the deployment data keys.
-    """
-    for uri in deployment_data.keys():
-        if check_if_chain_matches_chain_uri(w3, uri):
-            return uri
-    raise LinkerError(
-        "No matching blockchain URI found in deployment_data: "
-        f"{list(deployment_data.keys())}, for w3 instance: {w3.__repr__()}."
-    )
-
-
-def contains_matching_uri(deployment_data: Dict[str, Dict[str, str]], w3: Web3) -> bool:
-    """
-    Returns true if any blockchain uri in deployment data matches
-    w3-connected chain.
-    """
-    for uri in deployment_data.keys():
-        if check_if_chain_matches_chain_uri(w3, uri):
-            return True
-    return False
-
-
-def insert_deployment(
-    package: Package,
-    deployment_name: str,
-    deployment_data: Dict[str, str],
-    latest_block_uri: URI,
-) -> Manifest:
-    """
-    Returns a new manifest. If a matching chain uri is found
-    in the old manifest, it will update the chain uri along
-    with the new deployment data. If no match, it will simply add
-    the new chain uri and deployment data.
-    """
-    old_deployments_data = package.manifest.get("deployments")
-    if old_deployments_data and contains_matching_uri(old_deployments_data, package.w3):
-        old_chain_uri = pluck_matching_uri(old_deployments_data, package.w3)
-        old_deployments_chain_data = old_deployments_data[old_chain_uri]
-        # Replace specific on-chain deployment (i.e. deployment_name)
-        new_deployments_chain_data_init = dissoc(
-            old_deployments_chain_data, deployment_name
-        )
-        new_deployments_chain_data = {
-            **new_deployments_chain_data_init,
-            **{deployment_name: deployment_data},
-        }
-        # Replace all on-chain deployments
-        new_deployments_data_init = dissoc(
-            old_deployments_data, "deployments", old_chain_uri
-        )
-        new_deployments_data = {
-            **new_deployments_data_init,
-            **{latest_block_uri: new_deployments_chain_data},
-        }
-        return assoc(package.manifest, "deployments", new_deployments_data)
-
-    return assoc_in(
-        package.manifest,
-        ("deployments", latest_block_uri, deployment_name),
-        deployment_data,
-    )
-
-
-@to_dict
-def create_deployment_data(
-    contract_name: ContractName,
-    new_address: Address,
-    tx_receipt: TxReceipt,
-    link_refs: List[Dict[str, Any]] = None,
-) -> Iterable[Tuple[str, Any]]:
-    yield "contractType", contract_name
-    yield "address", new_address
-    yield "transaction", to_hex(tx_receipt["transactionHash"])
-    yield "block", to_hex(tx_receipt["blockHash"])
-    if link_refs:
-        yield "runtimeBytecode", {"linkDependencies": create_link_dep(link_refs)}
-
-
-@to_list
-def create_link_dep(link_refs: List[Dict[str, Any]]) -> Iterable[Dict[str, Any]]:
-    for link_ref in link_refs:
-        yield {
-            "offsets": link_ref["offsets"],
-            "type": "reference",
-            "value": link_ref["name"],
-        }
-
-
-def get_deployment_address(linked_type: str, package: Package) -> Address:
-    """
-    Return the address of a linked_type found in a package's manifest deployments.
-    """
-    try:
-        deployment_address = package.deployments.get(linked_type)["address"]
-    except KeyError:
-        raise LinkerError(
-            f"Package data does not contain a valid deployment of {linked_type} on the "
-            "current w3-connected chain."
-        )
-    return deployment_address

web3/tools/pytest_ethereum/deployer.py

@@ -1,48 +0,0 @@
-from typing import (
-    Any,
-    Callable,
-    Dict,
-)
-
-from eth_typing import (
-    ContractName,
-)
-
-from ethpm import (
-    Package,
-)
-from web3.tools.pytest_ethereum.exceptions import (
-    DeployerError,
-)
-from web3.tools.pytest_ethereum.linker import (
-    deploy,
-    linker,
-)
-
-
-class Deployer:
-    def __init__(self, package: Package) -> None:
-        if not isinstance(package, Package):
-            raise TypeError(
-                f"Expected a Package object, instead received {type(package)}."
-            )
-        self.package = package
-        self.strategies = {}  # type: Dict[str, Callable[[Package], Package]]
-
-    def deploy(self, contract_type: ContractName, *args: Any, **kwargs: Any) -> Package:
-        factory = self.package.get_contract_factory(contract_type)
-        if contract_type in self.strategies:
-            strategy = self.strategies[contract_type]
-            return strategy(self.package)
-        if factory.needs_bytecode_linking:
-            raise DeployerError(
-                "Unable to deploy an unlinked factory. "
-                "Please register a strategy for this contract type."
-            )
-        strategy = linker(deploy(contract_type, *args, **kwargs))
-        return strategy(self.package)
-
-    def register_strategy(
-        self, contract_type: ContractName, strategy: Callable[[Package], Package]
-    ) -> None:
-        self.strategies[contract_type] = strategy

web3/tools/pytest_ethereum/exceptions.py

@@ -1,22 +0,0 @@
-class PytestEthereumError(Exception):
-    """
-    Base class for all Pytest-Ethereum errors.
-    """
-
-    pass
-
-
-class DeployerError(PytestEthereumError):
-    """
-    Raised when the Deployer is unable to deploy a contract type.
-    """
-
-    pass
-
-
-class LinkerError(PytestEthereumError):
-    """
-    Raised when the Linker is unable to link two contract types.
-    """
-
-    pass