web3 6.20.2__py3-none-any.whl → 7.0.0__py3-none-any.whl

web3/middleware/fixture.py

@@ -1,190 +0,0 @@
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Dict,
-    Optional,
-    cast,
-)
-
-from web3.types import (
-    AsyncMiddleware,
-    AsyncMiddlewareCoroutine,
-    Middleware,
-    RPCEndpoint,
-    RPCResponse,
-)
-
-if TYPE_CHECKING:
-    from web3.main import (  # noqa: F401
-        AsyncWeb3,
-        Web3,
-    )
-    from web3.providers import (  # noqa: F401
-        PersistentConnectionProvider,
-    )
-
-
-def construct_fixture_middleware(fixtures: Dict[RPCEndpoint, Any]) -> Middleware:
-    """
-    Constructs a middleware which returns a static response for any method
-    which is found in the provided fixtures.
-    """
-
-    def fixture_middleware(
-        make_request: Callable[[RPCEndpoint, Any], Any], _: "Web3"
-    ) -> Callable[[RPCEndpoint, Any], RPCResponse]:
-        def middleware(method: RPCEndpoint, params: Any) -> RPCResponse:
-            if method in fixtures:
-                result = fixtures[method]
-                return {"result": result}
-            else:
-                return make_request(method, params)
-
-        return middleware
-
-    return fixture_middleware
-
-
-def construct_result_generator_middleware(
-    result_generators: Dict[RPCEndpoint, Any]
-) -> Middleware:
-    """
-    Constructs a middleware which intercepts requests for any method found in
-    the provided mapping of endpoints to generator functions, returning
-    whatever response the generator function returns.  Callbacks must be
-    functions with the signature `fn(method, params)`.
-    """
-
-    def result_generator_middleware(
-        make_request: Callable[[RPCEndpoint, Any], Any], _: "Web3"
-    ) -> Callable[[RPCEndpoint, Any], RPCResponse]:
-        def middleware(method: RPCEndpoint, params: Any) -> RPCResponse:
-            if method in result_generators:
-                result = result_generators[method](method, params)
-                return {"result": result}
-            else:
-                return make_request(method, params)
-
-        return middleware
-
-    return result_generator_middleware
-
-
-def construct_error_generator_middleware(
-    error_generators: Dict[RPCEndpoint, Any]
-) -> Middleware:
-    """
-    Constructs a middleware which intercepts requests for any method found in
-    the provided mapping of endpoints to generator functions, returning
-    whatever error message the generator function returns.  Callbacks must be
-    functions with the signature `fn(method, params)`.
-    """
-
-    def error_generator_middleware(
-        make_request: Callable[[RPCEndpoint, Any], Any], _: "Web3"
-    ) -> Callable[[RPCEndpoint, Any], RPCResponse]:
-        def middleware(method: RPCEndpoint, params: Any) -> RPCResponse:
-            if method in error_generators:
-                error = error_generators[method](method, params)
-                if isinstance(error, dict) and error.get("error", False):
-                    return {
-                        "error": {
-                            "code": error.get("code", -32000),
-                            "message": error["error"].get("message", ""),
-                            "data": error.get("data", ""),
-                        }
-                    }
-                else:
-                    return {"error": error}
-            else:
-                return make_request(method, params)
-
-        return middleware
-
-    return error_generator_middleware
-
-
-# --- async --- #
-
-
-async def async_construct_result_generator_middleware(
-    result_generators: Dict[RPCEndpoint, Any]
-) -> AsyncMiddleware:
-    """
-    Constructs a middleware which returns a static response for any method
-    which is found in the provided fixtures.
-    """
-
-    async def result_generator_middleware(
-        make_request: Callable[[RPCEndpoint, Any], Any], async_w3: "AsyncWeb3"
-    ) -> AsyncMiddlewareCoroutine:
-        async def middleware(method: RPCEndpoint, params: Any) -> Optional[RPCResponse]:
-            if method in result_generators:
-                result = result_generators[method](method, params)
-
-                if async_w3.provider.has_persistent_connection:
-                    provider = cast("PersistentConnectionProvider", async_w3.provider)
-                    response = await make_request(method, params)
-                    provider._request_processor.append_middleware_response_processor(
-                        # processed asynchronously later but need to pass the actual
-                        # response to the next middleware
-                        response,
-                        lambda _: {"result": result},
-                    )
-                    return response
-                else:
-                    return {"result": result}
-            else:
-                return await make_request(method, params)
-
-        return middleware
-
-    return result_generator_middleware
-
-
-async def async_construct_error_generator_middleware(
-    error_generators: Dict[RPCEndpoint, Any]
-) -> AsyncMiddleware:
-    """
-    Constructs a middleware which intercepts requests for any method found in
-    the provided mapping of endpoints to generator functions, returning
-    whatever error message the generator function returns.  Callbacks must be
-    functions with the signature `fn(method, params)`.
-    """
-
-    async def error_generator_middleware(
-        make_request: Callable[[RPCEndpoint, Any], Any], async_w3: "AsyncWeb3"
-    ) -> AsyncMiddlewareCoroutine:
-        async def middleware(method: RPCEndpoint, params: Any) -> Optional[RPCResponse]:
-            if method in error_generators:
-                error = error_generators[method](method, params)
-                if isinstance(error, dict) and error.get("error", False):
-                    error_response = {
-                        "error": {
-                            "code": error.get("code", -32000),
-                            "message": error["error"].get("message", ""),
-                            "data": error.get("data", ""),
-                        }
-                    }
-                else:
-                    error_response = {"error": error}
-
-                if async_w3.provider.has_persistent_connection:
-                    provider = cast("PersistentConnectionProvider", async_w3.provider)
-                    response = await make_request(method, params)
-                    provider._request_processor.append_middleware_response_processor(
-                        # processed asynchronously later but need to pass the actual
-                        # response to the next middleware
-                        response,
-                        lambda _: error_response,
-                    )
-                    return response
-                else:
-                    return cast(RPCResponse, error_response)
-            else:
-                return await make_request(method, params)
-
-        return middleware
-
-    return error_generator_middleware

web3/middleware/geth_poa.py

@@ -1,81 +0,0 @@
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-)
-
-from eth_utils import (
-    is_dict,
-)
-from eth_utils.curried import (
-    apply_formatter_if,
-    apply_formatters_to_dict,
-    apply_key_map,
-    is_null,
-)
-from eth_utils.toolz import (
-    complement,
-    compose,
-)
-from hexbytes import (
-    HexBytes,
-)
-
-from web3._utils.rpc_abi import (
-    RPC,
-)
-from web3.middleware.formatting import (
-    async_construct_formatting_middleware,
-    construct_formatting_middleware,
-)
-from web3.types import (
-    AsyncMiddlewareCoroutine,
-    RPCEndpoint,
-)
-
-if TYPE_CHECKING:
-    from web3 import (  # noqa: F401
-        AsyncWeb3,
-        Web3,
-    )
-
-is_not_null = complement(is_null)
-
-remap_geth_poa_fields = apply_key_map(
-    {
-        "extraData": "proofOfAuthorityData",
-    }
-)
-
-pythonic_geth_poa = apply_formatters_to_dict(
-    {
-        "proofOfAuthorityData": HexBytes,
-    }
-)
-
-geth_poa_cleanup = compose(pythonic_geth_poa, remap_geth_poa_fields)
-
-
-geth_poa_middleware = construct_formatting_middleware(
-    result_formatters={
-        RPC.eth_getBlockByHash: apply_formatter_if(is_not_null, geth_poa_cleanup),
-        RPC.eth_getBlockByNumber: apply_formatter_if(is_not_null, geth_poa_cleanup),
-    },
-)
-
-
-async def async_geth_poa_middleware(
-    make_request: Callable[[RPCEndpoint, Any], Any], w3: "AsyncWeb3"
-) -> AsyncMiddlewareCoroutine:
-    middleware = await async_construct_formatting_middleware(
-        result_formatters={
-            RPC.eth_getBlockByHash: apply_formatter_if(is_not_null, geth_poa_cleanup),
-            RPC.eth_getBlockByNumber: apply_formatter_if(is_not_null, geth_poa_cleanup),
-            RPC.eth_subscribe: apply_formatter_if(
-                is_not_null,
-                # original call to eth_subscribe returns a string, needs a dict check
-                apply_formatter_if(is_dict, geth_poa_cleanup),
-            ),
-        },
-    )
-    return await middleware(make_request, w3)

web3/middleware/normalize_request_parameters.py

@@ -1,11 +0,0 @@
-from web3._utils.method_formatters import (
-    METHOD_NORMALIZERS,
-)
-
-from .formatting import (
-    construct_formatting_middleware,
-)
-
-request_parameter_normalizer = construct_formatting_middleware(
-    request_formatters=METHOD_NORMALIZERS,
-)

web3/middleware/simulate_unmined_transaction.py

@@ -1,43 +0,0 @@
-import collections
-import itertools
-from typing import (
-    Any,
-    Callable,
-)
-
-from eth_typing import (
-    Hash32,
-)
-
-from web3 import (
-    Web3,
-)
-from web3.types import (
-    RPCEndpoint,
-    RPCResponse,
-    TxReceipt,
-)
-
-counter = itertools.count()
-
-INVOCATIONS_BEFORE_RESULT = 5
-
-
-def unmined_receipt_simulator_middleware(
-    make_request: Callable[[RPCEndpoint, Any], Any], w3: Web3
-) -> Callable[[RPCEndpoint, Any], RPCResponse]:
-    receipt_counters: DefaultDict[Hash32, TxReceipt] = collections.defaultdict(  # type: ignore # noqa: F821, E501
-        itertools.count
-    )
-
-    def middleware(method: RPCEndpoint, params: Any) -> RPCResponse:
-        if method == "eth_getTransactionReceipt":
-            txn_hash = params[0]
-            if next(receipt_counters[txn_hash]) < INVOCATIONS_BEFORE_RESULT:
-                return {"result": None}
-            else:
-                return make_request(method, params)
-        else:
-            return make_request(method, params)
-
-    return middleware