faster-eth-utils 4.1.7__cp314-cp314t-win_amd64.whl → 5.3.22__cp314-cp314t-win_amd64.whl

faster_eth_utils/address.py

@@ -2,10 +2,10 @@ import re
 from typing import (
     Any,
     Final,
-    Union,
-    cast,
+    TypeGuard,
 )
 
+import cchecksum
 from eth_typing import (
     Address,
     AnyAddress,
@@ -13,21 +13,13 @@ from eth_typing import (
     HexAddress,
     HexStr,
 )
-from typing_extensions import (
-    TypeGuard,
-)
 
 from .conversions import (
     hexstr_if_str,
     to_hex,
 )
-from .crypto import (
-    keccak,
-)
 from .hexadecimal import (
-    add_0x_prefix,
     decode_hex,
-    encode_hex,
     remove_0x_prefix,
 )
 from .types import (
@@ -38,6 +30,13 @@ from .types import (
 _HEX_ADDRESS_REGEXP: Final = re.compile("(0x)?[0-9a-f]{40}", re.IGNORECASE | re.ASCII)
 
 
+to_checksum_address: Final = cchecksum.to_checksum_address
+"""
+Makes a checksum address given a supported format.
+We use the `cchecksum` implementation for max speed.
+"""
+
+
 def is_hex_address(value: Any) -> TypeGuard[HexAddress]:
     """
     Checks if the given string of text type is an address in hexadecimal encoded form.
@@ -69,7 +68,7 @@ def is_address(value: Any) -> bool:
     return False
 
 
-def to_normalized_address(value: Union[AnyAddress, str, bytes]) -> HexAddress:
+def to_normalized_address(value: AnyAddress | str | bytes) -> HexAddress:
     """
     Converts an address to its normalized hexadecimal representation.
     """
@@ -90,14 +89,10 @@ def is_normalized_address(value: Any) -> TypeGuard[HexAddress]:
     """
     Returns whether the provided value is an address in its normalized form.
     """
-    if not is_address(value):
-        return False
-    else:
-        is_equal = value == to_normalized_address(value)
-        return cast(bool, is_equal)
+    return is_address(value) and value == to_normalized_address(value)
 
 
-def to_canonical_address(address: Union[AnyAddress, str, bytes]) -> Address:
+def to_canonical_address(address: AnyAddress | str | bytes) -> Address:
     """
     Convert a valid address to its canonical form (20-length bytes).
     """
@@ -111,42 +106,23 @@ def is_canonical_address(address: Any) -> TypeGuard[Address]:
     return is_binary_address(address) and address == to_canonical_address(address)
 8
 
-def is_same_address(left: AnyAddress, right: AnyAddress) -> bool:
+def is_same_address(
+    left: AnyAddress | str | bytes, right: AnyAddress | str | bytes
+) -> bool:
     """
     Checks if both addresses are same or not.
     """
     if not is_address(left) or not is_address(right):
         raise ValueError("Both values must be valid addresses")
-    else:
-        return bool(to_normalized_address(left) == to_normalized_address(right))
-
-
-def to_checksum_address(value: Union[AnyAddress, str, bytes]) -> ChecksumAddress:
-    """
-    Makes a checksum address given a supported format.
-    """
-    norm_address = to_normalized_address(value)
-    address_hash = encode_hex(keccak(text=remove_0x_prefix(HexStr(norm_address))))
-
-    checksum_address = add_0x_prefix(
-        HexStr(
-            "".join(
-                (
-                    norm_address[i].upper()
-                    if int(address_hash[i], 16) > 7
-                    else norm_address[i]
-                )
-                for i in range(2, 42)
-            )
-        )
-    )
-    return ChecksumAddress(HexAddress(checksum_address))
+    if left == right:
+        return True
+    return to_normalized_address(left) == to_normalized_address(right)
 
 
 def is_checksum_address(value: Any) -> TypeGuard[ChecksumAddress]:
     if not is_hex_address(value):
         return False
-    return bool(value == to_checksum_address(value))
+    return value == to_checksum_address(value)
 
 
 def _is_checksum_formatted(value: Any) -> bool:

faster_eth_utils/applicators.py

@@ -1,41 +1,54 @@
+from collections.abc import Callable, Generator, Mapping, Sequence
 from typing import (
+    TYPE_CHECKING,
     Any,
-    Callable,
-    Dict,
-    Generator,
-    List,
-    Tuple,
+    TypeGuard,
+    TypeVar,
+    cast,
+    overload,
 )
+
 import warnings
 
 from .decorators import (
     return_arg_type,
 )
-from .functional import (
-    to_dict,
+from .pydantic import (
+    CamelModel,
 )
 from .toolz import (
     compose,
     curry,
 )
 
-Formatters = Callable[[List[Any]], List[Any]]
+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]]
 
 
 @return_arg_type(2)
 def apply_formatter_at_index(
-    formatter: Callable[..., Any], at_index: int, value: List[Any]
-) -> Generator[List[Any], None, None]:
-    if at_index + 1 > len(value):
+    formatter: Callable[[TArg], TReturn],
+    at_index: int,
+    value: Sequence[TArg | TOther],
+) -> Generator[TOther | TReturn, None, None]:
+    try:
+        item = value[at_index]
+    except IndexError:
         raise IndexError(
             f"Not enough values in iterable to apply formatter. Got: {len(value)}. "
             f"Need: {at_index + 1}"
-        )
-    for index, item in enumerate(value):
-        if index == at_index:
-            yield formatter(item)
-        else:
-            yield item
+        ) from None
+
+    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: Callable[..., Any]) -> Formatters:
@@ -51,7 +64,7 @@ def combine_argument_formatters(*formatters: Callable[..., Any]) -> Formatters:
     )
 
     _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)
@@ -61,66 +74,100 @@ def combine_argument_formatters(*formatters: Callable[..., Any]) -> Formatters:
 
 @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 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}"
         )
-    elif len(formatters) < len(sequence):
+    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}"
         )
-    else:
-        for formatter, item in zip(formatters, sequence):
-            yield formatter(item)
 
 
+@overload
 def apply_formatter_if(
-    condition: Callable[..., bool], formatter: Callable[..., Any], value: Any
-) -> Any:
+    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
+) -> 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: Dict[Any, Any]
-) -> Generator[Tuple[Any, Any], None, None]:
-    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
+    formatters: dict[Any, Any],
+    value: dict[Any, Any] | CamelModel,
+    unaliased: bool = False,
+) -> 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
+    ``unaliased`` parameter.
+
+    :param formatters: The formatters to apply to the dictionary.
+    :param value: The dictionary-like object to apply the formatters to.
+    :param unaliased: If the model is a ``CamelModel``, whether to turn off
+        serialization by alias (camelCase).
+    :return: A generator that yields the formatted key-value pairs.
+    """
+    if isinstance(value, CamelModel):
+        value = value.model_dump(by_alias=not unaliased)
+
+    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[..., Any], value: List[Any]
-) -> Generator[List[Any], None, None]:
+    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)
@@ -130,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())
@@ -144,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,
@@ -22,18 +21,18 @@ from .hexadecimal import (
     remove_0x_prefix,
 )
 from .types import (
-    is_boolean,
-    is_integer,
     is_string,
 )
 
 T = TypeVar("T")
 
+BytesLike = Union[Primitives, bytearray, memoryview]
+
 
 def to_hex(
-    primitive: Optional[Primitives] = 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.
@@ -46,18 +45,22 @@ def to_hex(
     if text is not None:
         return encode_hex(text.encode("utf-8"))
 
-    if is_boolean(primitive):
+    if isinstance(primitive, bool):
         return HexStr("0x1") if primitive else HexStr("0x0")
 
     if isinstance(primitive, (bytes, bytearray)):
         return encode_hex(primitive)
+
+    if isinstance(primitive, memoryview):
+        return encode_hex(bytes(primitive))
+
     elif is_string(primitive):
         raise TypeError(
             "Unsupported type: The primitive argument must be one of: bytes,"
             "bytearray, int or bool and not str"
         )
 
-    if is_integer(primitive):
+    if isinstance(primitive, int):
         return HexStr(hex(primitive))
 
     raise TypeError(
@@ -67,9 +70,9 @@ def to_hex(
 
 
 def to_int(
-    primitive: Optional[Primitives] = 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.
@@ -77,8 +80,9 @@ def to_int(
 
      * primitive:
 
-       * bytes, bytearrays: big-endian integer
+       * bytes, bytearray, memoryview: big-endian integer
        * bool: True => 1, False => 0
+       * int: unchanged
      * hexstr: interpret hex as integer
      * text: interpret as string of digits, like '12' => 12
     """
@@ -88,6 +92,8 @@ def to_int(
         return int(text)
     elif isinstance(primitive, (bytes, bytearray)):
         return big_endian_to_int(primitive)
+    elif isinstance(primitive, memoryview):
+        return big_endian_to_int(bytes(primitive))
     elif isinstance(primitive, str):
         raise TypeError("Pass in strings with keyword hexstr or text")
     elif isinstance(primitive, (int, bool)):
@@ -100,21 +106,21 @@ def to_int(
 
 
 def to_bytes(
-    primitive: Optional[Primitives] = None,
-    hexstr: Optional[HexStr] = None,
-    text: Optional[str] = None,
+    primitive: BytesLike | None = None,
+    hexstr: HexStr | None = None,
+    text: str | None = None,
 ) -> bytes:
-    if is_boolean(primitive):
+    if isinstance(primitive, bool):
         return b"\x01" if primitive else b"\x00"
-    elif isinstance(primitive, bytearray):
+    elif isinstance(primitive, (bytearray, memoryview)):
         return bytes(primitive)
     elif isinstance(primitive, bytes):
         return primitive
-    elif is_integer(primitive):
-        return to_bytes(hexstr=to_hex(primitive))
+    elif isinstance(primitive, int):
+        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")
@@ -125,9 +131,9 @@ def to_bytes(
 
 
 def to_text(
-    primitive: Optional[Primitives] = 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")
@@ -137,14 +143,15 @@ def to_text(
         return to_text(hexstr=primitive)
     elif isinstance(primitive, (bytes, bytearray)):
         return primitive.decode("utf-8")
-    elif is_integer(primitive):
-        byte_encoding = int_to_big_endian(primitive)
-        return to_text(byte_encoding)
+    elif isinstance(primitive, memoryview):
+        return bytes(primitive).decode("utf-8")
+    elif isinstance(primitive, int):
+        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).
@@ -160,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,22 +46,17 @@ 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: str) -> Union[int, decimal.Decimal]:
-    """
-    Takes a number of wei and converts it to any other ether unit.
-    """
-    if unit.lower() not in units:
-        raise ValueError(f"Unknown unit. Must be one of {'/'.join(units.keys())}")
 
+def _from_wei(number: int, unit_value: decimal.Decimal) -> int | decimal.Decimal:
     if number == 0:
         return 0
 
     if number < MIN_WEI or number > MAX_WEI:
-        raise ValueError("value must be between 1 and 2**256 - 1")
-
-    unit_value = units[unit.lower()]
+        raise ValueError("value must be between 0 and 2**256 - 1")
 
     with localcontext() as ctx:
         ctx.prec = 999
@@ -71,13 +66,7 @@ def from_wei(number: int, unit: str) -> Union[int, decimal.Decimal]:
     return result_value
 
 
-def to_wei(number: Union[int, float, str, decimal.Decimal], unit: str) -> int:
-    """
-    Takes a number of a unit and converts it to wei.
-    """
-    if unit.lower() not in units:
-        raise ValueError(f"Unknown unit. Must be one of {'/'.join(units.keys())}")
-
+def _to_wei(number: _NumberType, unit_value: decimal.Decimal) -> int:
     if is_integer(number) or is_string(number):
         d_number = decimal.Decimal(value=number)  # type: ignore [arg-type]
     elif isinstance(number, float):
@@ -87,12 +76,11 @@ def to_wei(number: Union[int, float, str, decimal.Decimal], unit: str) -> int:
     else:
         raise TypeError("Unsupported type. Must be one of integer, float, or string")
 
-    s_number = str(number)
-    unit_value = units[unit.lower()]
-
-    if d_number == decimal.Decimal(0):
+    if d_number == DECIMAL_ZERO:
         return 0
 
+    s_number = str(number)
+
     if d_number < 1 and "." in s_number:
         with localcontext() as ctx:
             multiplier = len(s_number) - s_number.index(".") - 1
@@ -105,6 +93,52 @@ def to_wei(number: Union[int, float, str, decimal.Decimal], unit: str) -> int:
         result_value = decimal.Decimal(value=d_number, context=ctx) * unit_value
 
     if result_value < MIN_WEI or result_value > MAX_WEI:
-        raise ValueError("Resulting wei value must be between 1 and 2**256 - 1")
+        raise ValueError("Resulting wei value must be between 0 and 2**256 - 1")
 
     return int(result_value)
+
+
+def from_wei(number: int, unit: str) -> int | decimal.Decimal:
+    """
+    Takes a number of wei and converts it to any other ether unit.
+    """
+    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_key]
+
+    return _from_wei(number, unit_value)
+
+
+def to_wei(number: _NumberType, unit: str) -> int:
+    """
+    Takes a number of a unit and converts it to wei.
+    """
+    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_key]
+
+    return _to_wei(number, unit_value)
+
+
+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.
+    """
+    unit_value = decimal.Decimal(10) ** decimal.Decimal(value=decimals)
+
+    return _from_wei(number, unit_value)
+
+
+def to_wei_decimals(number: _NumberType, decimals: int) -> int:
+    """
+    Takes a number of a unit and converts it to wei with the specified
+    number of decimals.
+    """
+    unit_value = decimal.Decimal(10) ** decimal.Decimal(value=decimals)
+
+    return _to_wei(number, unit_value)