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

web3/_utils/filters.py

@@ -19,6 +19,7 @@ from eth_abi.grammar import (
     parse as parse_type_string,
 )
 from eth_typing import (
+    ABIEvent,
     ChecksumAddress,
     HexStr,
     TypeStr,
@@ -50,10 +51,11 @@ from web3._utils.validation import (
     validate_address,
 )
 from web3.exceptions import (
+    Web3TypeError,
     Web3ValidationError,
+    Web3ValueError,
 )
 from web3.types import (
-    ABIEvent,
     BlockIdentifier,
     FilterParams,
     LogReceipt,
@@ -71,8 +73,8 @@ def construct_event_filter_params(
     contract_address: Optional[ChecksumAddress] = None,
     argument_filters: Optional[Dict[str, Any]] = None,
     topics: Optional[Sequence[HexStr]] = None,
-    fromBlock: Optional[BlockIdentifier] = None,
-    toBlock: Optional[BlockIdentifier] = None,
+    from_block: Optional[BlockIdentifier] = None,
+    to_block: Optional[BlockIdentifier] = None,
     address: Optional[ChecksumAddress] = None,
 ) -> Tuple[List[List[Optional[HexStr]]], FilterParams]:
     filter_params: FilterParams = {}
@@ -82,17 +84,13 @@ def construct_event_filter_params(
 
     if topics is not None:
         if len(topic_set) > 1:
-            raise TypeError(
+            raise Web3TypeError(
                 "Merging the topics argument with topics generated "
                 "from argument_filters is not supported."
             )
         topic_set = topics
 
-    if len(topic_set) == 1 and is_list_like(topic_set[0]):
-        # type ignored b/c list-like check on line 88
-        filter_params["topics"] = topic_set[0]  # type: ignore
-    else:
-        filter_params["topics"] = topic_set
+    filter_params["topics"] = topic_set
 
     if address and contract_address:
         if is_list_like(address):
@@ -104,7 +102,7 @@ def construct_event_filter_params(
                 else [address]
             )
         else:
-            raise ValueError(
+            raise Web3ValueError(
                 f"Unsupported type for `address` parameter: {type(address)}"
             )
     elif address:
@@ -120,11 +118,11 @@ def construct_event_filter_params(
     else:
         validate_address(filter_params["address"])
 
-    if fromBlock is not None:
-        filter_params["fromBlock"] = fromBlock
+    if from_block is not None:
+        filter_params["fromBlock"] = from_block
 
-    if toBlock is not None:
-        filter_params["toBlock"] = toBlock
+    if to_block is not None:
+        filter_params["toBlock"] = to_block
 
     data_filters_set = construct_event_data_set(event_abi, abi_codec, argument_filters)
 
@@ -178,7 +176,7 @@ class BaseFilter:
 class Filter(BaseFilter):
     def __init__(self, filter_id: HexStr, eth_module: "Eth") -> None:
         self.eth_module = eth_module
-        super(Filter, self).__init__(filter_id)
+        super().__init__(filter_id)
 
     def get_new_entries(self) -> List[LogReceipt]:
         log_entries = self._filter_valid_entries(
@@ -196,7 +194,7 @@ class Filter(BaseFilter):
 class AsyncFilter(BaseFilter):
     def __init__(self, filter_id: HexStr, eth_module: "AsyncEth") -> None:
         self.eth_module = eth_module
-        super(AsyncFilter, self).__init__(filter_id)
+        super().__init__(filter_id)
 
     async def get_new_entries(self) -> List[LogReceipt]:
         filter_changes = await self.eth_module.get_filter_changes(self.filter_id)
@@ -250,7 +248,8 @@ class LogFilter(Filter):
     def set_data_filters(
         self, data_filter_set: Collection[Tuple[TypeStr, Any]]
     ) -> None:
-        """Sets the data filters (non indexed argument filters)
+        """
+        Sets the data filters (non indexed argument filters)
 
         Expects a set of tuples with the type and value, e.g.:
         (('uint256', [12345, 54321]), ('string', ('a-single-string',)))
@@ -292,7 +291,8 @@ class AsyncLogFilter(AsyncFilter):
     def set_data_filters(
         self, data_filter_set: Collection[Tuple[TypeStr, Any]]
     ) -> None:
-        """Sets the data filters (non indexed argument filters)
+        """
+        Sets the data filters (non indexed argument filters)
 
         Expects a set of tuples with the type and value, e.g.:
         (('uint256', [12345, 54321]), ('string', ('a-single-string',)))
@@ -318,7 +318,8 @@ normalize_to_text = apply_formatter_if(not_text, decode_utf8_bytes)
 
 
 def normalize_data_values(type_string: TypeStr, data_value: Any) -> Any:
-    """Decodes utf-8 bytes to strings for abi string values.
+    """
+    Decodes utf-8 bytes to strings for abi string values.
 
     eth-abi v1 returns utf-8 bytes for string values.
     This can be removed once eth-abi v2 is required.
@@ -326,7 +327,7 @@ def normalize_data_values(type_string: TypeStr, data_value: Any) -> Any:
     _type = parse_type_string(type_string)
     if _type.base == "string":
         if _type.arrlist is not None:
-            return tuple((normalize_to_text(value) for value in data_value))
+            return tuple(normalize_to_text(value) for value in data_value)
         else:
             return normalize_to_text(data_value)
     return data_value
@@ -336,7 +337,8 @@ def normalize_data_values(type_string: TypeStr, data_value: Any) -> Any:
 def match_fn(
     codec: ABICodec, match_values_and_abi: Collection[Tuple[str, Any]], data: Any
 ) -> bool:
-    """Match function used for filtering non-indexed event arguments.
+    """
+    Match function used for filtering non-indexed event arguments.
 
     Values provided through the match_values_and_abi parameter are
     compared to the abi decoded log data.
@@ -352,7 +354,7 @@ def match_fn(
         normalized_data = normalize_data_values(abi_type, data_value)
         for value in match_values:
             if not codec.is_encodable(abi_type, value):
-                raise ValueError(
+                raise Web3ValueError(
                     f"Value {value} is of the wrong abi type. "
                     f"Expected {abi_type} typed value."
                 )

web3/_utils/formatters.py

@@ -114,13 +114,13 @@ def apply_key_map(
 def is_array_of_strings(value: Any) -> bool:
     if not is_list_like(value):
         return False
-    return all((is_string(item) for item in value))
+    return all(is_string(item) for item in value)
 
 
 def is_array_of_dicts(value: Any) -> bool:
     if not is_list_like(value):
         return False
-    return all((is_dict(item) for item in value))
+    return all(is_dict(item) for item in value)
 
 
 @curry

web3/_utils/http.py

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

web3/_utils/http_session_manager.py

@@ -0,0 +1,303 @@
+import asyncio
+from concurrent.futures import (
+    ThreadPoolExecutor,
+)
+import logging
+import os
+import threading
+import time
+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.http import (
+    DEFAULT_HTTP_TIMEOUT,
+)
+from web3.exceptions import (
+    TimeExhausted,
+)
+from web3.utils.caching import (
+    SimpleCache,
+)
+
+
+class HTTPSessionManager:
+    logger = logging.getLogger("web3._utils.http_session_manager.HTTPSessionManager")
+    _lock: threading.Lock = threading.Lock()
+
+    def __init__(
+        self,
+        cache_size: int = 100,
+        session_pool_max_workers: int = 5,
+    ) -> None:
+        self.session_cache = SimpleCache(cache_size)
+        self.session_pool = ThreadPoolExecutor(max_workers=session_pool_max_workers)
+
+    @staticmethod
+    def get_default_http_endpoint() -> URI:
+        return URI(os.environ.get("WEB3_HTTP_PROVIDER_URI", "http://localhost:8545"))
+
+    def cache_and_return_session(
+        self,
+        endpoint_uri: URI,
+        session: requests.Session = None,
+        request_timeout: Optional[float] = None,
+    ) -> requests.Session:
+        # cache key should have a unique thread identifier
+        cache_key = generate_cache_key(f"{threading.get_ident()}:{endpoint_uri}")
+
+        cached_session = self.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 self._lock:
+            cached_session, evicted_items = self.session_cache.cache(cache_key, session)
+            self.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:
+                self.logger.debug(
+                    "Session cache full. Session evicted from cache: "
+                    f"{evicted_session}",
+                )
+            threading.Timer(
+                # If `request_timeout` is `None`, don't wait forever for the closing
+                # session to finish the request. Instead, wait over the default timeout.
+                request_timeout or DEFAULT_HTTP_TIMEOUT + 0.1,
+                self._close_evicted_sessions,
+                args=[evicted_sessions],
+            ).start()
+
+        return cached_session
+
+    def get_response_from_get_request(
+        self, endpoint_uri: URI, *args: Any, **kwargs: Any
+    ) -> requests.Response:
+        kwargs.setdefault("timeout", DEFAULT_HTTP_TIMEOUT)
+        session = self.cache_and_return_session(
+            endpoint_uri, request_timeout=kwargs["timeout"]
+        )
+        response = session.get(endpoint_uri, *args, **kwargs)
+        return response
+
+    def json_make_get_request(
+        self, endpoint_uri: URI, *args: Any, **kwargs: Any
+    ) -> Dict[str, Any]:
+        response = self.get_response_from_get_request(endpoint_uri, *args, **kwargs)
+        response.raise_for_status()
+        return response.json()
+
+    def get_response_from_post_request(
+        self, endpoint_uri: URI, *args: Any, **kwargs: Any
+    ) -> requests.Response:
+        session = self.cache_and_return_session(
+            endpoint_uri, request_timeout=kwargs["timeout"]
+        )
+        return session.post(endpoint_uri, *args, **kwargs)
+
+    def make_post_request(
+        self, endpoint_uri: URI, data: Union[bytes, Dict[str, Any]], **kwargs: Any
+    ) -> bytes:
+        kwargs.setdefault("timeout", DEFAULT_HTTP_TIMEOUT)
+        kwargs.setdefault("stream", False)
+
+        start = time.time()
+        timeout = kwargs["timeout"]
+
+        with self.get_response_from_post_request(
+            endpoint_uri, data=data, **kwargs
+        ) as response:
+            response.raise_for_status()
+            if kwargs.get("stream"):
+                return self._handle_streaming_response(response, start, timeout)
+            else:
+                return response.content
+
+    def _handle_streaming_response(
+        self, response: requests.Response, start: float, timeout: float
+    ) -> bytes:
+        response_body = b""
+        for data in response.iter_content():
+            response_body += data
+            # Manually manage timeout so streaming responses time out
+            # rather than resetting the timeout each time a response comes back
+            if (time.time() - start) > timeout:
+                raise TimeExhausted
+        return response_body
+
+    def _close_evicted_sessions(self, evicted_sessions: List[requests.Session]) -> None:
+        for evicted_session in evicted_sessions:
+            evicted_session.close()
+            self.logger.debug(f"Closed evicted session: {evicted_session}")
+
+    # -- async -- #
+
+    async def async_cache_and_return_session(
+        self,
+        endpoint_uri: URI,
+        session: Optional[ClientSession] = None,
+        request_timeout: Optional[ClientTimeout] = 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(self.session_pool, self._lock):
+            if cache_key not in self.session_cache:
+                if session is None:
+                    session = ClientSession(raise_for_status=True)
+
+                cached_session, evicted_items = self.session_cache.cache(
+                    cache_key, session
+                )
+                self.logger.debug(
+                    f"Async session cached: {endpoint_uri}, {cached_session}"
+                )
+
+            else:
+                # get the cached session
+                cached_session = self.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:
+                    self.logger.debug(
+                        f"{warning}: {endpoint_uri}, {cached_session}. "
+                        f"Creating and caching a new async session for uri."
+                    )
+
+                    self.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()
+                    self.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 = self.session_cache.cache(
+                        cache_key, _session
+                    )
+                    self.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 = list(evicted_items.values())
+            for evicted_session in evicted_sessions:
+                self.logger.debug(
+                    "Async session cache full. Session evicted from cache: "
+                    f"{evicted_session}",
+                )
+            # Kick off an asyncio `Task` 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 `request_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.
+            asyncio.create_task(
+                self._async_close_evicted_sessions(
+                    # if `ClientTimeout.total` is `None`, don't wait forever for the
+                    # closing session to finish the request. Instead, use the default
+                    # timeout.
+                    request_timeout.total or DEFAULT_HTTP_TIMEOUT + 0.1,
+                    evicted_sessions,
+                )
+            )
+
+        return cached_session
+
+    async def async_get_response_from_get_request(
+        self, endpoint_uri: URI, *args: Any, **kwargs: Any
+    ) -> ClientResponse:
+        kwargs.setdefault("timeout", ClientTimeout(DEFAULT_HTTP_TIMEOUT))
+        session = await self.async_cache_and_return_session(
+            endpoint_uri, request_timeout=kwargs["timeout"]
+        )
+        response = await session.get(endpoint_uri, *args, **kwargs)
+        return response
+
+    async def async_json_make_get_request(
+        self, endpoint_uri: URI, *args: Any, **kwargs: Any
+    ) -> Dict[str, Any]:
+        response = await self.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(
+        self, endpoint_uri: URI, *args: Any, **kwargs: Any
+    ) -> ClientResponse:
+        kwargs.setdefault("timeout", ClientTimeout(DEFAULT_HTTP_TIMEOUT))
+        session = await self.async_cache_and_return_session(
+            endpoint_uri, request_timeout=kwargs["timeout"]
+        )
+        response = await session.post(endpoint_uri, *args, **kwargs)
+        return response
+
+    async def async_make_post_request(
+        self, endpoint_uri: URI, data: Union[bytes, Dict[str, Any]], **kwargs: Any
+    ) -> bytes:
+        response = await self.async_get_response_from_post_request(
+            endpoint_uri, data=data, **kwargs
+        )
+        response.raise_for_status()
+        return await response.read()
+
+    async def _async_close_evicted_sessions(
+        self, timeout: float, evicted_sessions: List[ClientSession]
+    ) -> None:
+        await asyncio.sleep(timeout)
+
+        for evicted_session in evicted_sessions:
+            await evicted_session.close()
+            self.logger.debug(f"Closed evicted async session: {evicted_session}")
+
+        if any(not evicted_session.closed for evicted_session in evicted_sessions):
+            self.logger.warning(
+                "Some evicted async sessions were not properly closed: "
+                f"{evicted_sessions}"
+            )

web3/_utils/math.py

@@ -5,6 +5,7 @@ from typing import (
 
 from web3.exceptions import (
     InsufficientData,
+    Web3ValueError,
 )
 
 
@@ -17,23 +18,21 @@ def percentile(
             f"Expected a sequence of at least 1 integers, got {values!r}"
         )
     if percentile is None:
-        raise ValueError(f"Expected a percentile choice, got {percentile}")
+        raise Web3ValueError(f"Expected a percentile choice, got {percentile}")
+    if percentile < 0 or percentile > 100:
+        raise Web3ValueError("percentile must be in the range [0, 100]")
 
     sorted_values = sorted(values)
 
-    rank = len(values) * percentile / 100
-    if rank > 0:
-        index = rank - 1
-        if index < 0:
-            return sorted_values[0]
-    else:
-        index = rank
+    index = len(values) * percentile / 100 - 1
+    if index < 0:
+        return sorted_values[0]
 
-    if index % 1 == 0:
+    fractional = index % 1
+    if fractional == 0:
         return sorted_values[int(index)]
-    else:
-        fractional = index % 1
-        integer = int(index - fractional)
-        lower = sorted_values[integer]
-        higher = sorted_values[integer + 1]
-        return lower + fractional * (higher - lower)
+
+    integer = int(index - fractional)
+    lower = sorted_values[integer]
+    higher = sorted_values[integer + 1]
+    return lower + fractional * (higher - lower)