faster-eth-utils 5.3.2__cp312-cp312-musllinux_1_2_i686.whl → 5.3.22__cp312-cp312-musllinux_1_2_i686.whl

faster_eth_utils/decorators.py

@@ -1,69 +1,103 @@
 import functools
-import itertools
-import os
+from collections.abc import Callable
 from typing import (
     Any,
-    Callable,
-    Dict,
-    Optional,
-    Type,
+    Concatenate,
+    Final,
+    Generic,
     TypeVar,
     final,
 )
 
-from .types import (
-    is_text,
-)
+from typing_extensions import ParamSpec
+
+P = ParamSpec("P")
 
 T = TypeVar("T")
 
+TInstance = TypeVar("TInstance", bound=object)
+"""A TypeVar representing an instance that a method can bind to."""
+
 
 @final
-class combomethod:
-    def __init__(self, method: Callable[..., Any]) -> None:
-        self.method = method
+class combomethod(Generic[TInstance, P, T]):
+    def __init__(
+        self, method: Callable[Concatenate[TInstance | type[TInstance], P], T]
+    ) -> None:
+        self.method: Final = method
+
+    def __repr__(self) -> str:
+        return f"combomethod({self.method})"
 
     def __get__(
-        self, obj: Optional[T] = None, objtype: Optional[Type[T]] = None
-    ) -> Callable[..., Any]:
-        @functools.wraps(self.method)
-        def _wrapper(*args: Any, **kwargs: Any) -> Any:
-            if obj is not None:
-                return self.method(obj, *args, **kwargs)
-            else:
-                return self.method(objtype, *args, **kwargs)
+        self,
+        obj: TInstance | None,
+        objtype: type[TInstance],
+    ) -> Callable[P, T]:
+
+        method = self.method
+        bound_arg = objtype if obj is None else obj
+        
+        @functools.wraps(method)
+        def _wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+            return method(bound_arg, *args, **kwargs)
 
         return _wrapper
 
 
-def return_arg_type(at_position: int) -> Callable[..., Callable[..., T]]:
+_return_arg_type_deco_cache: Final[
+    dict[int, Callable[[Callable[P, T]], Callable[P, Any]]]
+] = {}
+# No need to hold so many unique instances in memory
+
+
+def return_arg_type(at_position: int) -> Callable[[Callable[P, T]], Callable[P, Any]]:
     """
     Wrap the return value with the result of `type(args[at_position])`.
     """
+    if deco := _return_arg_type_deco_cache.get(at_position):
+        return deco
 
-    def decorator(to_wrap: Callable[..., Any]) -> Callable[..., T]:
+    def decorator(to_wrap: Callable[P, Any]) -> Callable[P, Any]:
         @functools.wraps(to_wrap)
-        def wrapper(*args: Any, **kwargs: Any) -> T:  # type: ignore
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> Any:
             result = to_wrap(*args, **kwargs)
             ReturnType = type(args[at_position])
-            return ReturnType(result)  # type: ignore
+            return ReturnType(result)  # type: ignore [call-arg]
 
         return wrapper
 
+    _return_arg_type_deco_cache[at_position] = decorator
+
     return decorator
 
 
+ExcType = type[BaseException]
+
+ReplaceExceptionsCache = dict[
+    tuple[tuple[ExcType, ExcType], ...],
+    Callable[[Callable[P, T]], Callable[P, T]],
+]
+
+_replace_exceptions_deco_cache: Final[ReplaceExceptionsCache[..., Any]] = {}
+# No need to hold so many unique instances in memory
+
+
 def replace_exceptions(
-    old_to_new_exceptions: Dict[Type[BaseException], Type[BaseException]]
-) -> Callable[[Callable[..., T]], Callable[..., T]]:
+    old_to_new_exceptions: dict[ExcType, ExcType],
+) -> Callable[[Callable[P, T]], Callable[P, T]]:
     """
     Replaces old exceptions with new exceptions to be raised in their place.
     """
-    old_exceptions = tuple(old_to_new_exceptions.keys())
+    cache_key = tuple(old_to_new_exceptions.items())
+    if deco := _replace_exceptions_deco_cache.get(cache_key):
+        return deco
+
+    old_exceptions = tuple(old_to_new_exceptions)
 
-    def decorator(to_wrap: Callable[..., T]) -> Callable[..., T]:
+    def decorator(to_wrap: Callable[P, T]) -> Callable[P, T]:
         @functools.wraps(to_wrap)
-        def wrapped(*args: Any, **kwargs: Any) -> T:
+        def wrapped(*args: P.args, **kwargs: P.kwargs) -> T:
             try:
                 return to_wrap(*args, **kwargs)
             except old_exceptions as err:
@@ -76,4 +110,6 @@ def replace_exceptions(
 
         return wrapped
 
+    _replace_exceptions_deco_cache[cache_key] = decorator
+
     return decorator

faster_eth_utils/encoding.py

@@ -2,5 +2,5 @@ def int_to_big_endian(value: int) -> bytes:
     return value.to_bytes((value.bit_length() + 7) // 8 or 1, "big")
 
 
-def big_endian_to_int(value: bytes) -> int:
+def big_endian_to_int(value: bytes | bytearray) -> int:
     return int.from_bytes(value, "big")

faster_eth_utils/exceptions.py

@@ -1,4 +1,11 @@
-class ValidationError(Exception):
+"""
+faster-eth-utils exceptions always inherit from eth-utils exceptions, so porting to faster-eth-utils
+does not require any change to your existing exception handlers. They will continue to work.
+"""
+
+import eth_utils.exceptions
+
+class ValidationError(eth_utils.exceptions.ValidationError):  # type: ignore[misc]
     """
     Raised when something does not pass a validation check.
     """

faster_eth_utils/functional.py

@@ -1,23 +1,23 @@
 import collections
 import functools
 import itertools
+from collections.abc import Callable, Iterable, Mapping
 from typing import (  # noqa: F401
-    Any,
-    Callable,
     Dict,
-    Iterable,
     List,
-    Mapping,
     Set,
     Tuple,
     TypeVar,
     Union,
 )
 
+from typing_extensions import ParamSpec
+
 from .toolz import (
     compose as _compose,
 )
 
+P = ParamSpec("P")
 T = TypeVar("T")
 
 
@@ -33,41 +33,53 @@ TFOut = TypeVar("TFOut")
 def combine(
     f: Callable[[TGOut], TFOut], g: Callable[[TGIn], TGOut]
 ) -> Callable[[TGIn], TFOut]:
-    return lambda x: f(g(x))
+    def combined(x: TGIn) -> TFOut:
+        return f(g(x))
+    return combined
+
+
+TCb = TypeVar("TCb")
 
 
 def apply_to_return_value(
-    callback: Callable[..., T]
-) -> Callable[..., Callable[..., T]]:
-    def outer(fn: Callable[..., T]) -> Callable[..., T]:
-        # We would need to type annotate *args and **kwargs but doing so segfaults
-        # the PyPy builds. We ignore instead.
+    callback: Callable[[T], TCb]
+) -> Callable[[Callable[P, T]], Callable[P, TCb]]:
+    def outer(fn: Callable[P, T]) -> Callable[P, TCb]:
         @functools.wraps(fn)
-        def inner(*args, **kwargs) -> T:  # type: ignore
+        def inner(*args: P.args, **kwargs: P.kwargs) -> TCb:
             return callback(fn(*args, **kwargs))
-
         return inner
-
     return outer
 
 
 TVal = TypeVar("TVal")
 TKey = TypeVar("TKey")
-to_tuple = apply_to_return_value(
-    tuple
-)  # type: Callable[[Callable[..., Iterable[TVal]]], Callable[..., Tuple[TVal, ...]]]  # noqa: E501
-to_list = apply_to_return_value(
-    list
-)  # type: Callable[[Callable[..., Iterable[TVal]]], Callable[..., List[TVal]]]  # noqa: E501
-to_set = apply_to_return_value(
-    set
-)  # type: Callable[[Callable[..., Iterable[TVal]]], Callable[..., Set[TVal]]]  # noqa: E501
-to_dict = apply_to_return_value(
-    dict
-)  # type: Callable[[Callable[..., Iterable[Union[Mapping[TKey, TVal], Tuple[TKey, TVal]]]]], Callable[..., Dict[TKey, TVal]]]  # noqa: E501
-to_ordered_dict = apply_to_return_value(
+
+def to_tuple(fn: Callable[P, Iterable[TVal]]) -> Callable[P, tuple[TVal, ...]]:
+    def to_tuple_wrap(*args: P.args, **kwargs: P.kwargs) -> tuple[TVal, ...]:
+        return tuple(fn(*args, **kwargs))
+    return to_tuple_wrap
+
+def to_list(fn: Callable[P, Iterable[TVal]]) -> Callable[P, list[TVal]]:
+    def to_list_wrap(*args: P.args, **kwargs: P.kwargs) -> list[TVal]:
+        return list(fn(*args, **kwargs))
+    return to_list_wrap
+
+def to_set(fn: Callable[P, Iterable[TVal]]) -> Callable[P, set[TVal]]:
+    def to_set_wrap(*args: P.args, **kwargs: P.kwargs) -> set[TVal]:
+        return set(fn(*args, **kwargs))
+    return to_set_wrap
+
+def to_dict(
+    fn: Callable[P, Mapping[TKey, TVal] | Iterable[tuple[TKey, TVal]]]
+) -> Callable[P, dict[TKey, TVal]]:
+    def to_dict_wrap(*args: P.args, **kwargs: P.kwargs) -> dict[TKey, TVal]:
+        return dict(fn(*args, **kwargs))
+    return to_dict_wrap
+
+to_ordered_dict = apply_to_return_value(  # type: ignore [assignment]
     collections.OrderedDict
-)  # type: Callable[[Callable[..., Iterable[Union[Mapping[TKey, TVal], Tuple[TKey, TVal]]]]], Callable[..., collections.OrderedDict[TKey, TVal]]]  # noqa: E501
+)  # type: Callable[[Callable[P, Union[Mapping[TKey, TVal], Iterable[Tuple[TKey, TVal]]]]], Callable[P, collections.OrderedDict[TKey, TVal]]]  # noqa: E501
 sort_return = _compose(to_tuple, apply_to_return_value(sorted))
 flatten_return = _compose(
     to_tuple, apply_to_return_value(itertools.chain.from_iterable)

faster_eth_utils/hexadecimal.py

@@ -4,22 +4,18 @@ import binascii
 import re
 from typing import (
     Any,
-    AnyStr,
     Final,
-    Union,
+    TypeGuard,
 )
 
 from eth_typing import (
     HexStr,
 )
-from typing_extensions import (
-    TypeGuard,
-)
 
 _HEX_REGEXP_MATCH: Final = re.compile("(0[xX])?[0-9a-fA-F]*").fullmatch
 
-hexlify: Final = binascii.hexlify
-unhexlify: Final = binascii.unhexlify
+_hexlify: Final = binascii.hexlify
+_unhexlify: Final = binascii.unhexlify
 
 
 
@@ -29,11 +25,11 @@ def decode_hex(value: str) -> bytes:
     non_prefixed = remove_0x_prefix(HexStr(value))
     # unhexlify will only accept bytes type someday
     ascii_hex = non_prefixed.encode("ascii")
-    return unhexlify(ascii_hex)
+    return _unhexlify(ascii_hex)
 
 
-def encode_hex(value: AnyStr) -> HexStr:
-    ascii_bytes: Union[bytes, bytearray]
+def encode_hex(value: str | bytes | bytearray) -> HexStr:
+    ascii_bytes: bytes | bytearray
     if isinstance(value, (bytes, bytearray)):
         ascii_bytes = value
     elif isinstance(value, str):
@@ -41,7 +37,7 @@ def encode_hex(value: AnyStr) -> HexStr:
     else:
         raise TypeError("Value must be an instance of str or unicode")
 
-    binary_hex = hexlify(ascii_bytes)
+    binary_hex = _hexlify(ascii_bytes)
     return add_0x_prefix(HexStr(binary_hex.decode("ascii")))
 
 
@@ -51,7 +47,7 @@ def is_0x_prefixed(value: str) -> bool:
     #     raise TypeError(
     #         f"is_0x_prefixed requires text typed arguments. Got: {repr(value)}"
     #     )
-    return value.startswith(("0x", "0X"))
+    return value.startswith("0x") or value.startswith("0X")
 
 
 def remove_0x_prefix(value: HexStr) -> HexStr:

faster_eth_utils/humanize.py

@@ -1,10 +1,10 @@
+from collections.abc import (
+    Iterable,
+    Iterator,
+)
 from typing import (
     Any,
     Final,
-    Iterable,
-    Iterator,
-    Tuple,
-    Union,
 )
 from urllib import (
     parse,
@@ -23,17 +23,14 @@ from faster_eth_utils.currency import (
 from . import toolz
 
 
-sliding_window: Final = toolz.sliding_window
-take: Final = toolz.take
-
-
-def humanize_seconds(seconds: Union[float, int]) -> str:
-    if int(seconds) == 0:
+def humanize_seconds(seconds: float | int) -> str:
+    seconds_int = int(seconds)
+    if seconds_int == 0:
         return "0s"
 
-    unit_values = _consume_leading_zero_units(_humanize_seconds(int(seconds)))
+    unit_values = _consume_leading_zero_units(_humanize_seconds(seconds_int))
 
-    return "".join((f"{amount}{unit}" for amount, unit in take(3, unit_values)))
+    return "".join(f"{amount}{unit}" for amount, unit in toolz.take(3, unit_values))
 
 
 SECOND: Final = 1
@@ -57,8 +54,8 @@ UNITS: Final = (
 
 
 def _consume_leading_zero_units(
-    units_iter: Iterator[Tuple[int, str]]
-) -> Iterator[Tuple[int, str]]:
+    units_iter: Iterator[tuple[int, str]]
+) -> Iterator[tuple[int, str]]:
     for amount, unit in units_iter:
         if amount == 0:
             continue
@@ -69,7 +66,7 @@ def _consume_leading_zero_units(
     yield from units_iter
 
 
-def _humanize_seconds(seconds: int) -> Iterator[Tuple[int, str]]:
+def _humanize_seconds(seconds: int) -> Iterator[tuple[int, str]]:
     remainder = seconds
 
     for duration, unit in UNITS:
@@ -144,9 +141,9 @@ def _is_CIDv0_ipfs_hash(ipfs_hash: str) -> bool:
     return False
 
 
-def _find_breakpoints(values: Tuple[int, ...]) -> Iterator[int]:
+def _find_breakpoints(values: tuple[int, ...]) -> Iterator[int]:
     yield 0
-    for index, (left, right) in enumerate(sliding_window(2, values), 1):
+    for index, (left, right) in enumerate(toolz.sliding_window(2, values), 1):
         if left + 1 == right:
             continue
         else:
@@ -154,7 +151,7 @@ def _find_breakpoints(values: Tuple[int, ...]) -> Iterator[int]:
     yield len(values)
 
 
-def _extract_integer_ranges(values: Tuple[int, ...]) -> Iterator[Tuple[int, int]]:
+def _extract_integer_ranges(values: tuple[int, ...]) -> Iterator[tuple[int, int]]:
     """
     Return a tuple of consecutive ranges of integers.
 
@@ -164,12 +161,12 @@ def _extract_integer_ranges(values: Tuple[int, ...]) -> Iterator[Tuple[int, int]
     - fn(1, 2, 3, 7, 8, 9) -> ((1, 3), (7, 9))
     - fn(1, 7, 8, 9) -> ((1, 1), (7, 9))
     """
-    for left, right in sliding_window(2, _find_breakpoints(values)):
+    for left, right in toolz.sliding_window(2, _find_breakpoints(values)):
         chunk = values[left:right]
         yield chunk[0], chunk[-1]
 
 
-def _humanize_range(bounds: Tuple[int, int]) -> str:
+def _humanize_range(bounds: tuple[int, int]) -> str:
     left, right = bounds
     if left == right:
         return str(left)
@@ -201,5 +198,4 @@ def humanize_wei(number: int) -> str:
     else:
         unit = "wei"
     amount = from_wei(number, unit)
-    x = f"{str(amount)} {unit}"
-    return x
+    return f"{str(amount)} {unit}"

faster_eth_utils/logging.py

@@ -1,17 +1,19 @@
-import contextlib
+import logging
+from collections.abc import (
+    Iterator,
+)
+from contextlib import (
+    contextmanager,
+)
 from functools import (
     cached_property,
 )
-import logging
 from typing import (
     Any,
-    Dict,
-    Iterator,
-    Tuple,
-    Type,
+    Final,
     TypeVar,
-    Union,
     cast,
+    overload,
 )
 
 from .toolz import (
@@ -22,6 +24,11 @@ DEBUG2_LEVEL_NUM = 8
 
 TLogger = TypeVar("TLogger", bound=logging.Logger)
 
+Logger: Final = logging.Logger
+getLogger: Final = logging.getLogger
+getLoggerClass: Final = logging.getLoggerClass
+setLoggerClass: Final = logging.setLoggerClass
+
 
 class ExtendedDebugLogger(logging.Logger):
     """
@@ -41,7 +48,7 @@ class ExtendedDebugLogger(logging.Logger):
             # lambda to further speed up
             self.__dict__["debug2"] = lambda message, *args, **kwargs: None
 
-    def __reduce__(self) -> Tuple[Any, ...]:
+    def __reduce__(self) -> tuple[Any, ...]:
         # This is needed because our parent's implementation could
         # cause us to become a regular Logger on unpickling.
         return get_extended_debug_logger, (self.name,)
@@ -53,37 +60,38 @@ def setup_DEBUG2_logging() -> None:
     """
     if not hasattr(logging, "DEBUG2"):
         logging.addLevelName(DEBUG2_LEVEL_NUM, "DEBUG2")
-        logging.DEBUG2 = DEBUG2_LEVEL_NUM  # type: ignore
+        logging.DEBUG2 = DEBUG2_LEVEL_NUM  # type: ignore [attr-defined]
 
-
-@contextlib.contextmanager
-def _use_logger_class(logger_class: Type[logging.Logger]) -> Iterator[None]:
-    original_logger_class = logging.getLoggerClass()
-    logging.setLoggerClass(logger_class)
+@contextmanager
+def _use_logger_class(logger_class: type[logging.Logger]) -> Iterator[None]:
+    original_logger_class = getLoggerClass()
+    setLoggerClass(logger_class)
     try:
         yield
     finally:
-        logging.setLoggerClass(original_logger_class)
+        setLoggerClass(original_logger_class)
 
 
-def get_logger(name: str, logger_class: Union[Type[TLogger], None] = None) -> TLogger:
+@overload
+def get_logger(name: str, logger_class: type[TLogger]) -> TLogger: ...
+@overload
+def get_logger(name: str, logger_class: None = None) -> logging.Logger: ...
+def get_logger(name: str, logger_class: type[TLogger] | None = None) -> TLogger | logging.Logger:
     if logger_class is None:
-        return cast(TLogger, logging.getLogger(name))
-    else:
-        with _use_logger_class(logger_class):
-            # The logging module caches logger instances. The following code
-            # ensures that if there is a cached instance that we don't
-            # accidentally return the incorrect logger type because the logging
-            # module does not *update* the cached instance in the event that
-            # the global logging class changes.
-            #
-            # types ignored b/c mypy doesn't identify presence of
-            # manager on logging.Logger
-            manager = logging.Logger.manager
-            if name in manager.loggerDict:
-                if type(manager.loggerDict[name]) is not logger_class:
-                    del manager.loggerDict[name]
-            return cast(TLogger, logging.getLogger(name))
+        return getLogger(name)
+
+    with _use_logger_class(logger_class):
+        # The logging module caches logger instances. The following code
+        # ensures that if there is a cached instance that we don't
+        # accidentally return the incorrect logger type because the logging
+        # module does not *update* the cached instance in the event that
+        # the global logging class changes.
+        manager = Logger.manager
+        logger_dict = manager.loggerDict
+        cached_logger = logger_dict.get(name)
+        if cached_logger is not None and type(cached_logger) is not logger_class:
+            del logger_dict[name]
+        return cast(TLogger, getLogger(name))
 
 
 def get_extended_debug_logger(name: str) -> ExtendedDebugLogger:
@@ -101,13 +109,13 @@ class HasLoggerMeta(type):
     to use when creating the associated logger for a given class.
     """
 
-    logger_class = logging.Logger
+    logger_class = Logger
 
     def __new__(
-        mcls: Type[THasLoggerMeta],
+        mcls: type[THasLoggerMeta],
         name: str,
-        bases: Tuple[Type[Any]],
-        namespace: Dict[str, Any],
+        bases: tuple[type[Any]],
+        namespace: dict[str, Any],
     ) -> THasLoggerMeta:
         if "logger" in namespace:
             # If a logger was explicitly declared we shouldn't do anything to
@@ -115,22 +123,21 @@ class HasLoggerMeta(type):
             return super().__new__(mcls, name, bases, namespace)
         if "__qualname__" not in namespace:
             raise AttributeError("Missing __qualname__")
-
-        with _use_logger_class(mcls.logger_class):
-            logger = logging.getLogger(namespace["__qualname__"])
+    
+        logger = get_logger(namespace["__qualname__"], mcls.logger_class)
 
         return super().__new__(mcls, name, bases, assoc(namespace, "logger", logger))
 
     @classmethod
     def replace_logger_class(
-        mcls: Type[THasLoggerMeta], value: Type[logging.Logger]
-    ) -> Type[THasLoggerMeta]:
+        mcls: type[THasLoggerMeta], value: type[logging.Logger]
+    ) -> type[THasLoggerMeta]:
         return type(mcls.__name__, (mcls,), {"logger_class": value})
 
     @classmethod
     def meta_compat(
-        mcls: Type[THasLoggerMeta], other: Type[type]
-    ) -> Type[THasLoggerMeta]:
+        mcls: type[THasLoggerMeta], other: type[type]
+    ) -> type[THasLoggerMeta]:
         return type(mcls.__name__, (mcls, other), {})
 
 
@@ -141,5 +148,5 @@ class HasLogger(metaclass=HasLoggerMeta):
 HasExtendedDebugLoggerMeta = HasLoggerMeta.replace_logger_class(ExtendedDebugLogger)
 
 
-class HasExtendedDebugLogger(metaclass=HasExtendedDebugLoggerMeta):  # type: ignore
+class HasExtendedDebugLogger(metaclass=HasExtendedDebugLoggerMeta):  # type: ignore[metaclass]
     logger: ExtendedDebugLogger

faster_eth_utils/network.py

@@ -3,19 +3,26 @@ from dataclasses import (
 )
 import json
 import os
+import sys
+from pathlib import (
+    Path,
+)
 from typing import (
-    List,
+    Final,
 )
 
 from eth_typing import (
     ChainId,
 )
 
-from faster_eth_utils import (
+from faster_eth_utils.exceptions import (
     ValidationError,
 )
 
 
+FASTER_ETH_UTILS_FOLDER: Final = Path(sys.modules["faster_eth_utils"].__file__).parent  # type: ignore [arg-type]
+
+
 @dataclass
 class Network:
     chain_id: int
@@ -24,11 +31,11 @@ class Network:
     symbol: ChainId
 
 
-def initialize_network_objects() -> List[Network]:
+def initialize_network_objects() -> list[Network]:
     networks_obj = []
 
     networks_json_path = os.path.abspath(
-        os.path.join(os.path.dirname(__file__), "__json")
+        os.path.join(str(FASTER_ETH_UTILS_FOLDER), "__json")
     )
     with open(
         os.path.join(networks_json_path, "eth_networks.json"),