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/applicators.py

@@ -1,21 +1,18 @@
+from collections.abc import Callable, Generator, Mapping, Sequence
 from typing import (
+    TYPE_CHECKING,
     Any,
-    Callable,
-    Dict,
-    Generator,
-    List,
-    Tuple,
+    TypeGuard,
     TypeVar,
-    Union,
+    cast,
+    overload,
 )
+
 import warnings
 
 from .decorators import (
     return_arg_type,
 )
-from .functional import (
-    to_dict,
-)
 from .pydantic import (
     CamelModel,
 )
@@ -24,16 +21,23 @@ from .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")
 TReturn = TypeVar("TReturn")
+TOther = TypeVar("TOther")
 
-Formatters = Callable[[List[Any]], List[Any]]
+Formatters = Callable[[list[Any]], list[Any]]
 
 
 @return_arg_type(2)
 def apply_formatter_at_index(
-    formatter: Callable[..., Any], at_index: int, value: List[Any]
-) -> Generator[List[Any], None, None]:
+    formatter: Callable[[TArg], TReturn],
+    at_index: int,
+    value: Sequence[TArg | TOther],
+) -> Generator[TOther | TReturn, None, None]:
     try:
         item = value[at_index]
     except IndexError:
@@ -42,12 +46,12 @@ def apply_formatter_at_index(
             f"Need: {at_index + 1}"
         ) from None
 
-    yield from value[:at_index]
-    yield formatter(item)
-    yield from value[at_index + 1 :]
+    yield from cast(Sequence[TOther], value[:at_index])
+    yield formatter(cast(TArg, item))
+    yield from cast(Sequence[TOther], value[at_index + 1 :])
 
 
-def combine_argument_formatters(*formatters: List[Callable[..., Any]]) -> Formatters:
+def combine_argument_formatters(*formatters: Callable[..., Any]) -> Formatters:
     warnings.warn(
         DeprecationWarning(
             "combine_argument_formatters(formatter1, formatter2)([item1, item2])"
@@ -60,7 +64,7 @@ def combine_argument_formatters(*formatters: List[Callable[..., Any]]) -> Format
     )
 
     _formatter_at_index = curry(apply_formatter_at_index)
-    return compose(  # type: ignore
+    return compose(  # type: ignore [no-any-return]
         *(
             _formatter_at_index(formatter, index)
             for index, formatter in enumerate(formatters)
@@ -70,38 +74,55 @@ def combine_argument_formatters(*formatters: List[Callable[..., Any]]) -> Format
 
 @return_arg_type(1)
 def apply_formatters_to_sequence(
-    formatters: List[Any], sequence: List[Any]
-) -> Generator[List[Any], None, None]:
-    if len(formatters) == len(sequence):
+    formatters: list[Callable[[Any], TReturn]], sequence: Sequence[Any]
+) -> Generator[TReturn, None, None]:
+    num_formatters = len(formatters)
+    num_items = len(sequence)
+    if num_formatters == num_items:
         for formatter, item in zip(formatters, sequence):
             yield formatter(item)
-    elif len(formatters) > len(sequence):
+    elif num_formatters > num_items:
         raise IndexError(
-            f"Too many formatters for sequence: {len(formatters)} formatters for "
-            f"{repr(sequence)}"
+            f"Too many formatters for sequence: {num_formatters} formatters for "
+            f"{sequence!r}"
         )
     else:
         raise IndexError(
-            f"Too few formatters for sequence: {len(formatters)} formatters for "
-            f"{repr(sequence)}"
+            f"Too few formatters for sequence: {num_formatters} formatters for "
+            f"{sequence!r}"
         )
 
 
+@overload
+def apply_formatter_if(
+    condition: Callable[[TArg], TypeGuard[TOther]],
+    formatter: Callable[[TOther], TReturn],
+    value: TArg,
+) -> TArg | TReturn: ...
+
+
+@overload
 def apply_formatter_if(
     condition: Callable[[TArg], bool], formatter: Callable[[TArg], TReturn], value: TArg
-) -> Union[TArg, TReturn]:
+) -> TArg | TReturn: ...
+
+
+def apply_formatter_if(  # type: ignore [misc]
+    condition: Callable[[TArg], TypeGuard[TOther]] | Callable[[TArg], bool],
+    formatter: Callable[[TOther], TReturn] | Callable[[TArg], TReturn],
+    value: TArg,
+) -> TArg | TReturn:
     if condition(value):
-        return formatter(value)
+        return formatter(value)  # type: ignore [arg-type]
     else:
         return value
 
 
-@to_dict
 def apply_formatters_to_dict(
-    formatters: Dict[Any, Any],
-    value: Union[Dict[Any, Any], CamelModel],
+    formatters: dict[Any, Any],
+    value: dict[Any, Any] | CamelModel,
     unaliased: bool = False,
-) -> Generator[Tuple[Any, Any], None, None]:
+) -> dict[Any, Any]:
     """
     Apply formatters to a dictionary of values. If the value is a pydantic model,
     it will be serialized to a dictionary first, taking into account the
@@ -116,36 +137,37 @@ def apply_formatters_to_dict(
     if isinstance(value, CamelModel):
         value = value.model_dump(by_alias=not unaliased)
 
-    for key, item in value.items():
-        if key in formatters:
-            try:
-                yield key, formatters[key](item)
-            except ValueError as exc:
-                new_error_message = (
-                    f"Could not format invalid value {repr(item)} as field {repr(key)}"
-                )
-                raise ValueError(new_error_message) from exc
-            except TypeError as exc:
-                new_error_message = (
-                    f"Could not format invalid type {repr(item)} as field {repr(key)}"
-                )
-                raise TypeError(new_error_message) from exc
-        else:
-            yield key, item
+    def get_value(key: Any, val: Any) -> Any:
+        if key not in formatters:
+            return val
+        try:
+            return formatters[key](val)
+        except ValueError as exc:
+            raise ValueError(
+                f"Could not format invalid value {val!r} as field {key!r}"
+            ) from exc
+        except TypeError as exc:
+            raise TypeError(
+                f"Could not format invalid type {val!r} as field {key!r}"
+            ) from exc
+
+    return {key: get_value(key, val) for key, val in value.items()}
 
 
 @return_arg_type(1)
 def apply_formatter_to_array(
-    formatter: Callable[[TArg], TReturn], value: List[TArg]
+    formatter: Callable[[TArg], TReturn], value: Sequence[TArg]
 ) -> Generator[TReturn, None, None]:
     for item in value:
         yield formatter(item)
 
 
 def apply_one_of_formatters(
-    formatter_condition_pairs: Tuple[Tuple[Callable[..., Any], Callable[..., Any]]],
-    value: Any,
-) -> Any:
+    formatter_condition_pairs: tuple[
+        tuple[Callable[[TArg], "SupportsBool"], Callable[[TArg], TReturn]], ...
+    ],
+    value: TArg,
+) -> TReturn:
     for condition, formatter in formatter_condition_pairs:
         if condition(value):
             return formatter(value)
@@ -155,10 +177,9 @@ def apply_one_of_formatters(
         )
 
 
-@to_dict
 def apply_key_map(
-    key_mappings: Dict[Any, Any], value: Dict[Any, Any]
-) -> Generator[Tuple[Any, Any], None, None]:
+    key_mappings: dict[Any, Any], value: Mapping[Any, Any]
+) -> dict[Any, Any]:
     key_conflicts = (
         set(value.keys())
         .difference(key_mappings.keys())
@@ -169,8 +190,7 @@ def apply_key_map(
             f"Could not apply key map due to conflicting key(s): {key_conflicts}"
         )
 
-    for key, item in value.items():
-        if key in key_mappings:
-            yield key_mappings[key], item
-        else:
-            yield key, item
+    def get_key(key: Any) -> Any:
+        return key_mappings[key] if key in key_mappings else key
+
+    return {get_key(key): item for key, item in value.items()}

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)
@@ -261,6 +259,7 @@ apply_key_map = curry(apply_key_map)
 apply_one_of_formatters = curry(non_curried_apply_one_of_formatters)  # noqa: F811
 filter_abi_by_name = curry(filter_abi_by_name)
 filter_abi_by_type = curry(filter_abi_by_type)
+flatten_return = curry(flatten_return)
 from_wei = curry(from_wei)
 from_wei_decimals = curry(from_wei_decimals)
 get_aligned_abi_inputs = curry(get_aligned_abi_inputs)
@@ -268,7 +267,9 @@ get_logger = curry(get_logger)
 get_normalized_abi_inputs = curry(get_normalized_abi_inputs)
 hexstr_if_str = curry(non_curried_hexstr_if_str)  # noqa: F811
 is_same_address = curry(is_same_address)
+sort_return = curry(sort_return)
 text_if_str = curry(non_curried_text_if_str)  # noqa: F811
+to_ordered_dict = curry(to_ordered_dict)
 to_wei = curry(to_wei)
 to_wei_decimals = curry(to_wei_decimals)
 clamp = curry(clamp)
@@ -279,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