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

web3/_utils/request.py

@@ -1,265 +0,0 @@
-import asyncio
-from concurrent.futures import (
-    ThreadPoolExecutor,
-)
-import logging
-import os
-import threading
-from typing import (
-    Any,
-    Dict,
-    List,
-    Optional,
-    Union,
-)
-
-from aiohttp import (
-    ClientResponse,
-    ClientSession,
-    ClientTimeout,
-)
-from eth_typing import (
-    URI,
-)
-import requests
-
-from web3._utils.async_caching import (
-    async_lock,
-)
-from web3._utils.caching import (
-    generate_cache_key,
-)
-from web3.utils.caching import (
-    SimpleCache,
-)
-
-logger = logging.getLogger(__name__)
-
-DEFAULT_TIMEOUT = 10
-
-
-def get_default_http_endpoint() -> URI:
-    return URI(os.environ.get("WEB3_HTTP_PROVIDER_URI", "http://localhost:8545"))
-
-
-_session_cache = SimpleCache()
-_session_cache_lock = threading.Lock()
-
-
-def cache_and_return_session(
-    endpoint_uri: URI, session: requests.Session = None
-) -> requests.Session:
-    # cache key should have a unique thread identifier
-    cache_key = generate_cache_key(f"{threading.get_ident()}:{endpoint_uri}")
-
-    cached_session = _session_cache.get_cache_entry(cache_key)
-    if cached_session is not None:
-        # If read from cache yields a session, no need to lock; return the session.
-        # Sync is a bit simpler in this way since a `requests.Session` doesn't really
-        # "close" in the same way that an async `ClientSession` does. When "closed", it
-        # still uses http / https adapters successfully if a request is made.
-        return cached_session
-
-    if session is None:
-        session = requests.Session()
-
-    with _session_cache_lock:
-        cached_session, evicted_items = _session_cache.cache(cache_key, session)
-        logger.debug(f"Session cached: {endpoint_uri}, {cached_session}")
-
-    if evicted_items is not None:
-        evicted_sessions = evicted_items.values()
-        for evicted_session in evicted_sessions:
-            logger.debug(
-                f"Session cache full. Session evicted from cache: {evicted_session}",
-            )
-        threading.Timer(
-            DEFAULT_TIMEOUT + 0.1,
-            _close_evicted_sessions,
-            args=[evicted_sessions],
-        ).start()
-
-    return cached_session
-
-
-def get_response_from_get_request(
-    endpoint_uri: URI, *args: Any, **kwargs: Any
-) -> requests.Response:
-    kwargs.setdefault("timeout", DEFAULT_TIMEOUT)
-    session = cache_and_return_session(endpoint_uri)
-    response = session.get(endpoint_uri, *args, **kwargs)
-    return response
-
-
-def json_make_get_request(
-    endpoint_uri: URI, *args: Any, **kwargs: Any
-) -> Dict[str, Any]:
-    response = get_response_from_get_request(endpoint_uri, *args, **kwargs)
-    response.raise_for_status()
-    return response.json()
-
-
-def get_response_from_post_request(
-    endpoint_uri: URI, *args: Any, **kwargs: Any
-) -> requests.Response:
-    kwargs.setdefault("timeout", DEFAULT_TIMEOUT)
-    session = cache_and_return_session(endpoint_uri)
-    response = session.post(endpoint_uri, *args, **kwargs)
-    return response
-
-
-def make_post_request(
-    endpoint_uri: URI, data: Union[bytes, Dict[str, Any]], *args: Any, **kwargs: Any
-) -> bytes:
-    response = get_response_from_post_request(endpoint_uri, data=data, *args, **kwargs)
-    response.raise_for_status()
-    return response.content
-
-
-def _close_evicted_sessions(evicted_sessions: List[requests.Session]) -> None:
-    for evicted_session in evicted_sessions:
-        evicted_session.close()
-        logger.debug(f"Closed evicted session: {evicted_session}")
-
-
-# --- async --- #
-
-
-_async_session_cache = SimpleCache()
-_async_session_cache_lock = threading.Lock()
-_async_session_pool = ThreadPoolExecutor(max_workers=1)
-
-
-async def async_cache_and_return_session(
-    endpoint_uri: URI,
-    session: Optional[ClientSession] = None,
-) -> ClientSession:
-    # cache key should have a unique thread identifier
-    cache_key = generate_cache_key(f"{threading.get_ident()}:{endpoint_uri}")
-
-    evicted_items = None
-    async with async_lock(_async_session_pool, _async_session_cache_lock):
-        if cache_key not in _async_session_cache:
-            if session is None:
-                session = ClientSession(raise_for_status=True)
-
-            cached_session, evicted_items = _async_session_cache.cache(
-                cache_key, session
-            )
-            logger.debug(f"Async session cached: {endpoint_uri}, {cached_session}")
-
-        else:
-            # get the cached session
-            cached_session = _async_session_cache.get_cache_entry(cache_key)
-            session_is_closed = cached_session.closed
-            session_loop_is_closed = cached_session._loop.is_closed()
-
-            warning = (
-                "Async session was closed"
-                if session_is_closed
-                else (
-                    "Loop was closed for async session"
-                    if session_loop_is_closed
-                    else None
-                )
-            )
-            if warning:
-                logger.debug(
-                    f"{warning}: {endpoint_uri}, {cached_session}. "
-                    f"Creating and caching a new async session for uri."
-                )
-
-                _async_session_cache._data.pop(cache_key)
-                if not session_is_closed:
-                    # if loop was closed but not the session, close the session
-                    await cached_session.close()
-                logger.debug(
-                    f"Async session closed and evicted from cache: {cached_session}"
-                )
-
-                # replace stale session with a new session at the cache key
-                _session = ClientSession(raise_for_status=True)
-                cached_session, evicted_items = _async_session_cache.cache(
-                    cache_key, _session
-                )
-                logger.debug(f"Async session cached: {endpoint_uri}, {cached_session}")
-
-    if evicted_items is not None:
-        # At this point the evicted sessions are already popped out of the cache and
-        # just stored in the `evicted_sessions` dict. So we can kick off a future task
-        # to close them and it should be safe to pop out of the lock here.
-        evicted_sessions = evicted_items.values()
-        for evicted_session in evicted_sessions:
-            logger.debug(
-                "Async session cache full. Session evicted from cache: "
-                f"{evicted_session}",
-            )
-        # Kick off a future task, in a separate thread, to close the evicted
-        # sessions. In the case that the cache filled very quickly and some
-        # sessions have been evicted before their original request has been made,
-        # we set the timer to a bit more than the `DEFAULT_TIMEOUT` for a call. This
-        # should make it so that any call from an evicted session can still be made
-        # before the session is closed.
-        threading.Timer(
-            DEFAULT_TIMEOUT + 0.1,
-            _async_close_evicted_sessions,
-            args=[evicted_sessions],
-        ).start()
-
-    return cached_session
-
-
-async def async_get_response_from_get_request(
-    endpoint_uri: URI, *args: Any, **kwargs: Any
-) -> ClientResponse:
-    kwargs.setdefault("timeout", ClientTimeout(DEFAULT_TIMEOUT))
-    session = await async_cache_and_return_session(endpoint_uri)
-    response = await session.get(endpoint_uri, *args, **kwargs)
-    return response
-
-
-async def async_json_make_get_request(
-    endpoint_uri: URI, *args: Any, **kwargs: Any
-) -> Dict[str, Any]:
-    response = await async_get_response_from_get_request(endpoint_uri, *args, **kwargs)
-    response.raise_for_status()
-    return await response.json()
-
-
-async def async_get_response_from_post_request(
-    endpoint_uri: URI, *args: Any, **kwargs: Any
-) -> ClientResponse:
-    kwargs.setdefault("timeout", ClientTimeout(DEFAULT_TIMEOUT))
-    session = await async_cache_and_return_session(endpoint_uri)
-    response = await session.post(endpoint_uri, *args, **kwargs)
-    return response
-
-
-async def async_make_post_request(
-    endpoint_uri: URI, data: Union[bytes, Dict[str, Any]], *args: Any, **kwargs: Any
-) -> bytes:
-    response = await async_get_response_from_post_request(
-        endpoint_uri, data=data, *args, **kwargs
-    )
-    response.raise_for_status()
-    return await response.read()
-
-
-async def async_get_json_from_client_response(
-    response: ClientResponse,
-) -> Dict[str, Any]:
-    return await response.json()
-
-
-def _async_close_evicted_sessions(evicted_sessions: List[ClientSession]) -> None:
-    loop = asyncio.new_event_loop()
-
-    for evicted_session in evicted_sessions:
-        loop.run_until_complete(evicted_session.close())
-        logger.debug(f"Closed evicted async session: {evicted_session}")
-
-    if any(not evicted_session.closed for evicted_session in evicted_sessions):
-        logger.warning(
-            f"Some evicted async sessions were not properly closed: {evicted_sessions}"
-        )
-    loop.close()

web3/middleware/abi.py

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

web3/middleware/async_cache.py

@@ -1,99 +0,0 @@
-from concurrent.futures import (
-    ThreadPoolExecutor,
-)
-import threading
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Collection,
-)
-
-from web3._utils.async_caching import (
-    async_lock,
-)
-from web3._utils.caching import (
-    generate_cache_key,
-)
-from web3.middleware.cache import (
-    SIMPLE_CACHE_RPC_WHITELIST,
-    _should_cache_response,
-)
-from web3.types import (
-    AsyncMiddleware,
-    AsyncMiddlewareCoroutine,
-    Middleware,
-    RPCEndpoint,
-    RPCResponse,
-)
-from web3.utils.caching import (
-    SimpleCache,
-)
-
-if TYPE_CHECKING:
-    from web3 import (  # noqa: F401
-        AsyncWeb3,
-        Web3,
-    )
-
-_async_request_thread_pool = ThreadPoolExecutor()
-
-
-async def async_construct_simple_cache_middleware(
-    cache: SimpleCache = None,
-    rpc_whitelist: Collection[RPCEndpoint] = SIMPLE_CACHE_RPC_WHITELIST,
-    should_cache_fn: Callable[
-        [RPCEndpoint, Any, RPCResponse], bool
-    ] = _should_cache_response,
-) -> AsyncMiddleware:
-    """
-    Constructs a middleware which caches responses based on the request
-    ``method`` and ``params``
-
-    :param cache: A ``SimpleCache`` class.
-    :param rpc_whitelist: A set of RPC methods which may have their responses cached.
-    :param should_cache_fn: A callable which accepts ``method`` ``params`` and
-        ``response`` and returns a boolean as to whether the response should be
-        cached.
-    """
-
-    async def async_simple_cache_middleware(
-        make_request: Callable[[RPCEndpoint, Any], Any], _async_w3: "AsyncWeb3"
-    ) -> AsyncMiddlewareCoroutine:
-        lock = threading.Lock()
-
-        # It's not imperative that we define ``_cache`` here rather than in
-        # ``async_construct_simple_cache_middleware``. Due to the nature of async,
-        # construction is awaited and doesn't happen at import. This means separate
-        # instances would still get unique caches. However, to keep the code consistent
-        # with the synchronous version, and provide less ambiguity, we define it
-        # similarly to the synchronous version here.
-        _cache = cache if cache else SimpleCache(256)
-
-        async def middleware(method: RPCEndpoint, params: Any) -> RPCResponse:
-            if method in rpc_whitelist:
-                cache_key = generate_cache_key(
-                    f"{threading.get_ident()}:{(method, params)}"
-                )
-                cached_request = _cache.get_cache_entry(cache_key)
-                if cached_request is not None:
-                    return cached_request
-
-                response = await make_request(method, params)
-                if should_cache_fn(method, params, response):
-                    async with async_lock(_async_request_thread_pool, lock):
-                        _cache.cache(cache_key, response)
-                return response
-            else:
-                return await make_request(method, params)
-
-        return middleware
-
-    return async_simple_cache_middleware
-
-
-async def _async_simple_cache_middleware(
-    make_request: Callable[[RPCEndpoint, Any], Any], async_w3: "AsyncWeb3"
-) -> Middleware:
-    middleware = await async_construct_simple_cache_middleware()
-    return await middleware(make_request, async_w3)