faster-eth-utils 5.3.8__cp313-cp313-win_amd64.whl → 5.3.23__cp313-cp313-win_amd64.whl

faster_eth_utils/conversions.py

@@ -1,9 +1,8 @@
 from typing import (
-    Callable,
-    Optional,
     TypeVar,
     Union,
 )
+from collections.abc import Callable
 
 from eth_typing import (
     HexStr,
@@ -31,9 +30,9 @@ BytesLike = Union[Primitives, bytearray, memoryview]
 
 
 def to_hex(
-    primitive: Optional[BytesLike] = None,
-    hexstr: Optional[HexStr] = None,
-    text: Optional[str] = None,
+    primitive: BytesLike | None = None,
+    hexstr: HexStr | None = None,
+    text: str | None = None,
 ) -> HexStr:
     """
     Auto converts any supported value into its hex representation.
@@ -71,9 +70,9 @@ def to_hex(
 
 
 def to_int(
-    primitive: Optional[BytesLike] = None,
-    hexstr: Optional[HexStr] = None,
-    text: Optional[str] = None,
+    primitive: BytesLike | None = None,
+    hexstr: HexStr | None = None,
+    text: str | None = None,
 ) -> int:
     """
     Converts value to its integer representation.
@@ -107,9 +106,9 @@ def to_int(
 
 
 def to_bytes(
-    primitive: Optional[BytesLike] = None,
-    hexstr: Optional[HexStr] = None,
-    text: Optional[str] = None,
+    primitive: BytesLike | None = None,
+    hexstr: HexStr | None = None,
+    text: str | None = None,
 ) -> bytes:
     if isinstance(primitive, bool):
         return b"\x01" if primitive else b"\x00"
@@ -118,10 +117,10 @@ def to_bytes(
     elif isinstance(primitive, bytes):
         return primitive
     elif isinstance(primitive, int):
-        return to_bytes(hexstr=to_hex(primitive))
+        return int_to_big_endian(primitive)
     elif hexstr is not None:
         if len(hexstr) % 2:
-            hexstr = "0x0" + remove_0x_prefix(hexstr)  # type: ignore [assignment]
+            hexstr = HexStr(f"0x0{remove_0x_prefix(hexstr)}")
         return decode_hex(hexstr)
     elif text is not None:
         return text.encode("utf-8")
@@ -132,9 +131,9 @@ def to_bytes(
 
 
 def to_text(
-    primitive: Optional[BytesLike] = None,
-    hexstr: Optional[HexStr] = None,
-    text: Optional[str] = None,
+    primitive: BytesLike | None = None,
+    hexstr: HexStr | None = None,
+    text: str | None = None,
 ) -> str:
     if hexstr is not None:
         return to_bytes(hexstr=hexstr).decode("utf-8")
@@ -147,13 +146,12 @@ def to_text(
     elif isinstance(primitive, memoryview):
         return bytes(primitive).decode("utf-8")
     elif isinstance(primitive, int):
-        byte_encoding = int_to_big_endian(primitive)
-        return to_text(byte_encoding)
+        return int_to_big_endian(primitive).decode("utf-8")
     raise TypeError("Expected an int, bytes, bytearray or hexstr.")
 
 
 def text_if_str(
-    to_type: Callable[..., T], text_or_primitive: Union[bytes, int, str]
+    to_type: Callable[..., T], text_or_primitive: bytes | int | str
 ) -> T:
     """
     Convert to a type, assuming that strings can be only unicode text (not a hexstr).
@@ -169,7 +167,7 @@ def text_if_str(
 
 
 def hexstr_if_str(
-    to_type: Callable[..., T], hexstr_or_primitive: Union[bytes, int, str]
+    to_type: Callable[..., T], hexstr_or_primitive: bytes | int | str
 ) -> T:
     """
     Convert to a type, assuming that strings can be only hexstr (not unicode text).

faster_eth_utils/crypto.py

@@ -1,8 +1,3 @@
-from typing import (
-    Optional,
-    Union,
-)
-
 from eth_hash.auto import (
     keccak as keccak_256,
 )
@@ -14,8 +9,8 @@ from .conversions import (
 
 
 def keccak(
-    primitive: Optional[Union[bytes, int, bool]] = None,
-    hexstr: Optional[HexStr] = None,
-    text: Optional[str] = None,
+    primitive: bytes | int | bool | None = None,
+    hexstr: HexStr | None = None,
+    text: str | None = None,
 ) -> bytes:
     return bytes(keccak_256(to_bytes(primitive, hexstr, text)))

faster_eth_utils/currency.py

@@ -46,11 +46,12 @@ class denoms:
 
 MIN_WEI: Final = 0
 MAX_WEI: Final = 2**256 - 1
+DECIMAL_ZERO: Final = decimal.Decimal(0)
 
 _NumberType = Union[int, float, str, decimal.Decimal]
 
 
-def _from_wei(number: int, unit_value: decimal.Decimal) -> Union[int, decimal.Decimal]:
+def _from_wei(number: int, unit_value: decimal.Decimal) -> int | decimal.Decimal:
     if number == 0:
         return 0
 
@@ -75,7 +76,7 @@ def _to_wei(number: _NumberType, unit_value: decimal.Decimal) -> int:
     else:
         raise TypeError("Unsupported type. Must be one of integer, float, or string")
 
-    if d_number == decimal.Decimal(0):
+    if d_number == DECIMAL_ZERO:
         return 0
 
     s_number = str(number)
@@ -97,14 +98,15 @@ def _to_wei(number: _NumberType, unit_value: decimal.Decimal) -> int:
     return int(result_value)
 
 
-def from_wei(number: int, unit: str) -> Union[int, decimal.Decimal]:
+def from_wei(number: int, unit: str) -> int | decimal.Decimal:
     """
     Takes a number of wei and converts it to any other ether unit.
     """
-    if unit.lower() not in units:
+    unit_key = unit.lower()
+    if unit_key not in units:
         raise ValueError(f"Unknown unit. Must be one of {'/'.join(units.keys())}")
 
-    unit_value = units[unit.lower()]
+    unit_value = units[unit_key]
 
     return _from_wei(number, unit_value)
 
@@ -113,15 +115,16 @@ def to_wei(number: _NumberType, unit: str) -> int:
     """
     Takes a number of a unit and converts it to wei.
     """
-    if unit.lower() not in units:
+    unit_key = unit.lower()
+    if unit_key not in units:
         raise ValueError(f"Unknown unit. Must be one of {'/'.join(units.keys())}")
 
-    unit_value = units[unit.lower()]
+    unit_value = units[unit_key]
 
     return _to_wei(number, unit_value)
 
 
-def from_wei_decimals(number: int, decimals: int) -> Union[int, decimal.Decimal]:
+def from_wei_decimals(number: int, decimals: int) -> int | decimal.Decimal:
     """
     Takes a number of wei and converts it to a decimal with the specified
     number of decimals.

faster_eth_utils/curried/__init__.py

@@ -1,11 +1,10 @@
+import sys
+from collections.abc import Callable, Generator, Sequence
 from typing import (
+    TYPE_CHECKING,
     Any,
-    Callable,
-    Dict,
-    Generator,
     Optional,
-    Sequence,
-    Tuple,
+    TypeGuard,
     TypeVar,
     Union,
     overload,
@@ -118,138 +117,137 @@ from faster_eth_utils.toolz import (
     curry,
 )
 
+if TYPE_CHECKING:
+    from _typeshed import SupportsBool
+    # We have to sacrifice a little bit of specificity on dinosaur Python3.8
+
+
+TArg = TypeVar("TArg")
+TOther = TypeVar("TOther")
 TReturn = TypeVar("TReturn")
 TValue = TypeVar("TValue")
 
 
 @overload
 def apply_formatter_if(
-    condition: Callable[..., bool],
-) -> Callable[[Callable[..., TReturn]], Callable[[TValue], Union[TReturn, TValue]]]:
-    pass
-
+    condition: Callable[[TArg], TypeGuard[TOther]],
+) -> Callable[[Callable[[TOther], TReturn]], Callable[[TArg], TReturn | TArg]]:
+    ...
 
 @overload
 def apply_formatter_if(
-    condition: Callable[..., bool], formatter: Callable[..., TReturn]
-) -> Callable[[TValue], Union[TReturn, TValue]]:
-    pass
-
+    condition: Callable[[TArg], TypeGuard[TOther]], formatter: Callable[[TOther], TReturn]
+) -> Callable[[TArg], TReturn | TArg]:
+    ...
 
 @overload
 def apply_formatter_if(
-    condition: Callable[..., bool], formatter: Callable[..., TReturn], value: TValue
-) -> Union[TReturn, TValue]:
-    pass
+    condition: Callable[[TArg], TypeGuard[TOther]], formatter: Callable[[TOther], TReturn], value: TArg
+) -> TReturn | TArg:
+    ...
 
+@overload
+def apply_formatter_if(
+    condition: Callable[[TArg], bool], formatter: Callable[[TArg], TReturn], value: TArg
+) -> TReturn | TArg:
+    ...
 
-# This is just a stub to appease mypy, it gets overwritten later
 def apply_formatter_if(  # type: ignore
-    condition: Callable[..., bool],
-    formatter: Optional[Callable[..., TReturn]] = None,
-    value: Optional[TValue] = None,
-) -> Union[
-    Callable[[Callable[..., TReturn]], Callable[[TValue], Union[TReturn, TValue]]],
-    Callable[[TValue], Union[TReturn, TValue]],
-    TReturn,
-    TValue,
-]:
+    condition: Callable[[TArg], TypeGuard[TOther]] | Callable[[TArg], bool],
+    formatter: Callable[[TOther], TReturn] | Callable[[TArg], TReturn] | None = None,
+    value: TArg | None = None,
+) -> (
+    Callable[[Callable[[TOther], TReturn]], Callable[[TArg], TReturn | TArg]] |
+    Callable[[TArg], TReturn | TArg] |
+    TReturn |
+    TArg
+):
     pass
 
 
 @overload
 def apply_one_of_formatters(
     formatter_condition_pairs: Sequence[
-        Tuple[Callable[..., bool], Callable[..., TReturn]]
+        tuple[Callable[[TArg], "SupportsBool"], Callable[[TArg], TReturn]]
     ],
-) -> Callable[[TValue], TReturn]:
-    ...
+) -> Callable[[TArg], TReturn]: ...
 
 
 @overload
 def apply_one_of_formatters(
     formatter_condition_pairs: Sequence[
-        Tuple[Callable[..., bool], Callable[..., TReturn]]
+        tuple[Callable[[TArg], "SupportsBool"], Callable[[TArg], TReturn]]
     ],
-    value: TValue,
-) -> TReturn:
-    ...
+    value: TArg,
+) -> TReturn: ...
 
 
 # This is just a stub to appease mypy, it gets overwritten later
-def apply_one_of_formatters(  # type: ignore
+def apply_one_of_formatters(  # type: ignore[empty-body]
     formatter_condition_pairs: Sequence[
-        Tuple[Callable[..., bool], Callable[..., TReturn]]
+        tuple[Callable[[TArg], "SupportsBool"], Callable[[TArg], TReturn]]
     ],
-    value: Optional[TValue] = None,
-) -> TReturn:
-    ...
+    value: TArg | None = None,
+) -> Callable[[TArg], TReturn] | TReturn: ...
 
 
 @overload
 def hexstr_if_str(
     to_type: Callable[..., TReturn],
-) -> Callable[[Union[bytes, int, str]], TReturn]:
-    ...
+) -> Callable[[bytes | int | str], TReturn]: ...
 
 
 @overload
 def hexstr_if_str(
-    to_type: Callable[..., TReturn], to_format: Union[bytes, int, str]
-) -> TReturn:
-    ...
+    to_type: Callable[..., TReturn], to_format: bytes | int | str
+) -> TReturn: ...
 
 
 # This is just a stub to appease mypy, it gets overwritten later
 def hexstr_if_str(  # type: ignore
-    to_type: Callable[..., TReturn], to_format: Optional[Union[bytes, int, str]] = None
-) -> TReturn:
-    ...
+    to_type: Callable[..., TReturn], to_format: bytes | int | str | None = None
+) -> TReturn: ...
 
 
 @overload
 def text_if_str(
     to_type: Callable[..., TReturn],
-) -> Callable[[Union[bytes, int, str]], TReturn]:
-    ...
+) -> Callable[[bytes | int | str], TReturn]: ...
 
 
 @overload
 def text_if_str(
-    to_type: Callable[..., TReturn], text_or_primitive: Union[bytes, int, str]
-) -> TReturn:
-    ...
+    to_type: Callable[..., TReturn], text_or_primitive: bytes | int | str
+) -> TReturn: ...
 
 
 # This is just a stub to appease mypy, it gets overwritten later
 def text_if_str(  # type: ignore
     to_type: Callable[..., TReturn],
-    text_or_primitive: Optional[Union[bytes, int, str]] = None,
-) -> TReturn:
-    ...
+    text_or_primitive: bytes | int | str | None = None,
+) -> TReturn: ...
 
 
 @overload
 def apply_formatters_to_dict(
-    formatters: Dict[Any, Any], unaliased: bool = False
-) -> Callable[[Dict[Any, Any]], TReturn]:
+    formatters: dict[Any, Any], unaliased: bool = False
+) -> Callable[[dict[Any, Any] | CamelModel], dict[Any, Any]]:
     ...
 
 
 @overload
 def apply_formatters_to_dict(
-    formatters: Dict[Any, Any], value: Union[Dict[Any, Any], CamelModel]
-) -> Dict[Any, Any]:
+    formatters: dict[Any, Any], value: dict[Any, Any] | CamelModel, unaliased: bool = False
+) -> dict[Any, Any]:
     ...
 
 
 # This is just a stub to appease mypy, it gets overwritten later
-def apply_formatters_to_dict(  # type: ignore
-    formatters: Dict[Any, Any],
-    value: Optional[Union[Dict[Any, Any], CamelModel]] = None,
+def apply_formatters_to_dict(
+    formatters: dict[Any, Any],
+    value: dict[Any, Any] | CamelModel | None = None,
     unaliased: bool = False,
-) -> Dict[Any, Any]:
-    ...
+) -> dict[Any, Any]: ...
 
 
 apply_formatter_at_index = curry(apply_formatter_at_index)
@@ -282,13 +280,12 @@ clamp = curry(clamp)
 # `from eth_utils.curried import *`
 del Any
 del Callable
-del Dict
 del Generator
 del Optional
 del Sequence
 del TReturn
 del TValue
-del Tuple
+del TypeGuard
 del TypeVar
 del Union
 del curry

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,12 +1,10 @@
 import collections
 import functools
 import itertools
+from collections.abc import Callable, Iterable, Mapping
 from typing import (  # noqa: F401
-    Callable,
     Dict,
-    Iterable,
     List,
-    Mapping,
     Set,
     Tuple,
     TypeVar,
@@ -57,25 +55,25 @@ def apply_to_return_value(
 TVal = TypeVar("TVal")
 TKey = TypeVar("TKey")
 
-def to_tuple(fn: Callable[P, Iterable[TVal]]) -> Callable[P, Tuple[TVal, ...]]:
-    def to_tuple_wrap(*args: P.args, **kwargs: P.kwargs) -> Tuple[TVal, ...]:
+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]:
+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]:
+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, Union[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]:
+    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