faster-eth-utils 5.3.19__cp311-cp311-win32.whl → 5.3.23__cp311-cp311-win32.whl

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,18 +1,14 @@
 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,
 )
-from typing_extensions import TypeGuard
 
 from faster_eth_utils import (
     CamelModel,
@@ -122,11 +118,8 @@ from faster_eth_utils.toolz import (
 )
 
 if TYPE_CHECKING:
-    if sys.version_info >= (3, 9):
-        from _typeshed import SupportsBool
+    from _typeshed import SupportsBool
     # We have to sacrifice a little bit of specificity on dinosaur Python3.8
-    else:
-        SupportsBool = Any
 
 
 TArg = TypeVar("TArg")
@@ -138,44 +131,44 @@ TValue = TypeVar("TValue")
 @overload
 def apply_formatter_if(
     condition: Callable[[TArg], TypeGuard[TOther]],
-) -> Callable[[Callable[[TOther], TReturn]], Callable[[TArg], Union[TReturn, TArg]]]:
+) -> Callable[[Callable[[TOther], TReturn]], Callable[[TArg], TReturn | TArg]]:
     ...
 
 @overload
 def apply_formatter_if(
     condition: Callable[[TArg], TypeGuard[TOther]], formatter: Callable[[TOther], TReturn]
-) -> Callable[[TArg], Union[TReturn, TArg]]:
+) -> Callable[[TArg], TReturn | TArg]:
     ...
 
 @overload
 def apply_formatter_if(
     condition: Callable[[TArg], TypeGuard[TOther]], formatter: Callable[[TOther], TReturn], value: TArg
-) -> Union[TReturn, TArg]:
+) -> TReturn | TArg:
     ...
 
 @overload
 def apply_formatter_if(
     condition: Callable[[TArg], bool], formatter: Callable[[TArg], TReturn], value: TArg
-) -> Union[TReturn, TArg]:
+) -> TReturn | TArg:
     ...
 
 def apply_formatter_if(  # type: ignore
-    condition: Union[Callable[[TArg], TypeGuard[TOther]], Callable[[TArg], bool]],
-    formatter: Optional[Union[Callable[[TOther], TReturn], Callable[[TArg], TReturn]]] = None,
-    value: Optional[TArg] = None,
-) -> Union[
-    Callable[[Callable[[TOther], TReturn]], Callable[[TArg], Union[TReturn, TArg]]],
-    Callable[[TArg], Union[TReturn, TArg]],
-    TReturn,
-    TArg,
-]:
+    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[[TArg], "SupportsBool"], Callable[[TArg], TReturn]]
+        tuple[Callable[[TArg], "SupportsBool"], Callable[[TArg], TReturn]]
     ],
 ) -> Callable[[TArg], TReturn]: ...
 
@@ -183,78 +176,78 @@ def apply_one_of_formatters(
 @overload
 def apply_one_of_formatters(
     formatter_condition_pairs: Sequence[
-        Tuple[Callable[[TArg], "SupportsBool"], Callable[[TArg], TReturn]]
+        tuple[Callable[[TArg], "SupportsBool"], Callable[[TArg], TReturn]]
     ],
     value: TArg,
 ) -> TReturn: ...
 
 
 # This is just a stub to appease mypy, it gets overwritten later
-def apply_one_of_formatters(
+def apply_one_of_formatters(  # type: ignore[empty-body]
     formatter_condition_pairs: Sequence[
-        Tuple[Callable[[TArg], "SupportsBool"], Callable[[TArg], TReturn]]
+        tuple[Callable[[TArg], "SupportsBool"], Callable[[TArg], TReturn]]
     ],
-    value: Optional[TArg] = 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]
+    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
+    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]
+    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,
+    text_or_primitive: bytes | int | str | None = None,
 ) -> TReturn: ...
 
 
 @overload
 def apply_formatters_to_dict(
-    formatters: Dict[Any, Any], unaliased: bool = False
-) -> Callable[[Union[Dict[Any, Any], CamelModel]], Dict[Any, Any]]:
+    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], unaliased: bool = False
-) -> 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(
-    formatters: Dict[Any, Any],
-    value: Optional[Union[Dict[Any, Any], CamelModel]] = None,
+    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)
@@ -287,13 +280,11 @@ 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

faster_eth_utils/decorators.py

@@ -1,19 +1,15 @@
 import functools
+from collections.abc import Callable
 from typing import (
     Any,
-    Callable,
-    Dict,
+    Concatenate,
     Final,
     Generic,
-    Optional,
-    Tuple,
-    Type,
     TypeVar,
-    Union,
     final,
 )
 
-from typing_extensions import Concatenate, ParamSpec
+from typing_extensions import ParamSpec
 
 P = ParamSpec("P")
 
@@ -26,7 +22,7 @@ TInstance = TypeVar("TInstance", bound=object)
 @final
 class combomethod(Generic[TInstance, P, T]):
     def __init__(
-        self, method: Callable[Concatenate[Union[TInstance, Type[TInstance]], P], T]
+        self, method: Callable[Concatenate[TInstance | type[TInstance], P], T]
     ) -> None:
         self.method: Final = method
 
@@ -35,22 +31,22 @@ class combomethod(Generic[TInstance, P, T]):
 
     def __get__(
         self,
-        obj: Optional[TInstance],
-        objtype: Type[TInstance],
+        obj: TInstance | None,
+        objtype: type[TInstance],
     ) -> Callable[P, T]:
 
-        @functools.wraps(self.method)
+        method = self.method
+        bound_arg = objtype if obj is None else obj
+        
+        @functools.wraps(method)
         def _wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
-            if obj is not None:
-                return self.method(obj, *args, **kwargs)
-            else:
-                return self.method(objtype, *args, **kwargs)  # type: ignore [arg-type]
+            return method(bound_arg, *args, **kwargs)
 
         return _wrapper
 
 
 _return_arg_type_deco_cache: Final[
-    Dict[int, Callable[[Callable[P, T]], Callable[P, Any]]]
+    dict[int, Callable[[Callable[P, T]], Callable[P, Any]]]
 ] = {}
 # No need to hold so many unique instances in memory
 
@@ -76,10 +72,10 @@ def return_arg_type(at_position: int) -> Callable[[Callable[P, T]], Callable[P,
     return decorator
 
 
-ExcType = Type[BaseException]
+ExcType = type[BaseException]
 
-ReplaceExceptionsCache = Dict[
-    Tuple[Tuple[ExcType, ExcType], ...],
+ReplaceExceptionsCache = dict[
+    tuple[tuple[ExcType, ExcType], ...],
     Callable[[Callable[P, T]], Callable[P, T]],
 ]
 
@@ -88,7 +84,7 @@ _replace_exceptions_deco_cache: Final[ReplaceExceptionsCache[..., Any]] = {}
 
 
 def replace_exceptions(
-    old_to_new_exceptions: Dict[ExcType, ExcType],
+    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.

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

@@ -5,7 +5,7 @@ does not require any change to your existing exception handlers. They will conti
 
 import eth_utils.exceptions
 
-class ValidationError(eth_utils.exceptions.ValidationError):
+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
 

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,13 +23,14 @@ from faster_eth_utils.currency import (
 from . import toolz
 
 
-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 toolz.take(3, unit_values)))
+    return "".join(f"{amount}{unit}" for amount, unit in toolz.take(3, unit_values))
 
 
 SECOND: Final = 1
@@ -53,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
@@ -65,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:
@@ -140,7 +141,7 @@ 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(toolz.sliding_window(2, values), 1):
         if left + 1 == right:
@@ -150,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.
 
@@ -165,7 +166,7 @@ def _extract_integer_ranges(values: Tuple[int, ...]) -> Iterator[Tuple[int, int]
         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)
@@ -197,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}"