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

faster_eth_utils/address.py

@@ -1,17 +1,43 @@
 import re
-from typing import Any, Final, Union, cast
+from typing import (
+    Any,
+    Final,
+    TypeGuard,
+)
+
+import cchecksum
+from eth_typing import (
+    Address,
+    AnyAddress,
+    ChecksumAddress,
+    HexAddress,
+    HexStr,
+)
+
+from .conversions import (
+    hexstr_if_str,
+    to_hex,
+)
+from .hexadecimal import (
+    decode_hex,
+    remove_0x_prefix,
+)
+from .types import (
+    is_bytes,
+    is_text,
+)
 
-from eth_typing import Address, AnyAddress, ChecksumAddress, HexAddress, HexStr
+_HEX_ADDRESS_REGEXP: Final = re.compile("(0x)?[0-9a-f]{40}", re.IGNORECASE | re.ASCII)
 
-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 is_bytes, is_text
 
-_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) -> bool:
+def is_hex_address(value: Any) -> TypeGuard[HexAddress]:
     """
     Checks if the given string of text type is an address in hexadecimal encoded form.
     """
@@ -20,7 +46,7 @@ def is_hex_address(value: Any) -> bool:
     return _HEX_ADDRESS_REGEXP.fullmatch(value) is not None
 
 
-def is_binary_address(value: Any) -> bool:
+def is_binary_address(value: Any) -> TypeGuard[bytes]:
     """
     Checks if the given string is an address in raw bytes form.
     """
@@ -36,105 +62,67 @@ def is_address(value: Any) -> bool:
     """
     Is the given string an address in any of the known formats?
     """
-    if is_hex_address(value):
-        if _is_checksum_formatted(value):
-            return is_checksum_address(value)
-        return True
-
-    if is_binary_address(value):
+    if is_hex_address(value) or is_binary_address(value):
         return True
 
     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.
     """
     try:
         hex_address = hexstr_if_str(to_hex, value).lower()
     except AttributeError:
-        raise TypeError(
-            "Value must be any string, instead got type {}".format(type(value))
-        )
+        raise TypeError(f"Value must be any string, instead got type {type(value)}")
     if is_address(hex_address):
         return HexAddress(HexStr(hex_address))
     else:
         raise ValueError(
-            "Unknown format {!r}, attempted to normalize to {!r}".format(
-                value, hex_address
-            )
+            f"Unknown format {repr(value)}, attempted to normalize to "
+            f"{repr(hex_address)}"
         )
 
 
-def is_normalized_address(value: Any) -> bool:
+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).
     """
     return Address(decode_hex(to_normalized_address(address)))
 
 
-def is_canonical_address(address: Any) -> bool:
+def is_canonical_address(address: Any) -> TypeGuard[Address]:
     """
     Returns `True` if the `value` is an address in its canonical form.
     """
-    if not is_bytes(address) or len(address) != 20:
-        return False
-    is_equal = address == to_canonical_address(address)
-    return cast(bool, is_equal)
-
+    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 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) -> bool:
-    if not is_text(value):
-        return False
 
+def is_checksum_address(value: Any) -> TypeGuard[ChecksumAddress]:
     if not is_hex_address(value):
         return False
-    is_equal = value == to_checksum_address(value)
-    return cast(bool, is_equal)
+    return value == to_checksum_address(value)
 
 
 def _is_checksum_formatted(value: Any) -> bool:

faster_eth_utils/applicators.py

@@ -1,30 +1,57 @@
-from typing import Any, Callable, Dict, Generator, List, Tuple
+from collections.abc import Callable, Generator, Mapping, Sequence
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    TypeGuard,
+    TypeVar,
+    cast,
+    overload,
+)
+
 import warnings
 
-from .decorators import return_arg_type
-from .functional import to_dict
-from .toolz import compose, curry
+from .decorators import (
+    return_arg_type,
+)
+from .pydantic import (
+    CamelModel,
+)
+from .toolz import (
+    compose,
+    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]:
-    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(
-            "Not enough values in iterable to apply formatter.  Got: {0}. "
-            "Need: {1}".format(len(value), at_index + 1)
-        )
-    for index, item in enumerate(value):
-        if index == at_index:
-            yield formatter(item)
-        else:
-            yield item
+            f"Not enough values in iterable to apply formatter. Got: {len(value)}. "
+            f"Need: {at_index + 1}"
+        ) 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: List[Callable[..., Any]]) -> Formatters:
+
+def combine_argument_formatters(*formatters: Callable[..., Any]) -> Formatters:
     warnings.warn(
         DeprecationWarning(
             "combine_argument_formatters(formatter1, formatter2)([item1, item2])"
@@ -32,11 +59,12 @@ def combine_argument_formatters(*formatters: List[Callable[..., Any]]) -> Format
             "release of the eth-utils library. Update your calls to use "
             "apply_formatters_to_sequence([formatter1, formatter2], [item1, item2]) "
             "instead."
-        )
+        ),
+        stacklevel=2,
     )
 
     _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)
@@ -46,69 +74,100 @@ 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 num_formatters > num_items:
         raise IndexError(
-            "Too many formatters for sequence: {} formatters for {!r}".format(
-                len(formatters), sequence
-            )
+            f"Too many formatters for sequence: {num_formatters} formatters for "
+            f"{sequence!r}"
         )
-    elif len(formatters) < len(sequence):
+    else:
         raise IndexError(
-            "Too few formatters for sequence: {} formatters for {!r}".format(
-                len(formatters), 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 = "Could not format invalid value %r as field %r" % (
-                    item,
-                    key,
-                )
-                raise ValueError(new_error_message) from exc
-            except TypeError as exc:
-                new_error_message = (
-                    "Could not format invalid type of %r for field %r" % (item, 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)
@@ -118,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())
@@ -129,13 +187,10 @@ def apply_key_map(
     )
     if key_conflicts:
         raise KeyError(
-            "Could not apply key map due to conflicting key(s): {}".format(
-                key_conflicts
-            )
+            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,8 +1,18 @@
-from typing import Callable, TypeVar, Union
+from typing import (
+    TypeVar,
+    Union,
+)
+from collections.abc import Callable
 
-from eth_typing import HexStr, Primitives
+from eth_typing import (
+    HexStr,
+    Primitives,
+)
 
-from .encoding import big_endian_to_int, int_to_big_endian
+from .encoding import (
+    big_endian_to_int,
+    int_to_big_endian,
+)
 from .hexadecimal import (
     add_0x_prefix,
     decode_hex,
@@ -10,13 +20,19 @@ from .hexadecimal import (
     is_hexstr,
     remove_0x_prefix,
 )
-from .types import is_boolean, is_integer, is_string
+from .types import (
+    is_string,
+)
 
 T = TypeVar("T")
 
+BytesLike = Union[Primitives, bytearray, memoryview]
+
 
 def to_hex(
-    primitive: Primitives = None, hexstr: HexStr = None, text: str = None
+    primitive: BytesLike | None = None,
+    hexstr: HexStr | None = None,
+    text: str | None = None,
 ) -> HexStr:
     """
     Auto converts any supported value into its hex representation.
@@ -29,28 +45,34 @@ 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(
-        "Unsupported type: '{0}'.  Must be one of: bool, str, bytes, bytearray"
-        "or int.".format(repr(type(primitive)))
+        f"Unsupported type: '{repr(type(primitive))}'. Must be one of: bool, str, "
+        "bytes, bytearray or int."
     )
 
 
 def to_int(
-    primitive: Primitives = None, hexstr: HexStr = None, text: str = None
+    primitive: BytesLike | None = None,
+    hexstr: HexStr | None = None,
+    text: str | None = None,
 ) -> int:
     """
     Converts value to its integer representation.
@@ -58,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
     """
@@ -69,33 +92,35 @@ 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)):
         return int(primitive)
     else:
         raise TypeError(
-            "Invalid type.  Expected one of int/bool/str/bytes/bytearray.  Got "
-            "{0}".format(type(primitive))
+            "Invalid type. Expected one of int/bool/str/bytes/bytearray. Got "
+            f"{type(primitive)}"
         )
 
 
 def to_bytes(
-    primitive: Primitives = None, hexstr: HexStr = None, text: 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:
-            # type check ignored here because casting an
-            # Optional arg to str is not possible
-            hexstr = "0x0" + remove_0x_prefix(hexstr)  # type: ignore
+            hexstr = HexStr(f"0x0{remove_0x_prefix(hexstr)}")
         return decode_hex(hexstr)
     elif text is not None:
         return text.encode("utf-8")
@@ -106,7 +131,9 @@ def to_bytes(
 
 
 def to_text(
-    primitive: Primitives = None, hexstr: HexStr = None, text: 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")
@@ -116,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).
@@ -139,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).
@@ -153,9 +181,8 @@ def hexstr_if_str(
             hexstr_or_primitive
         ):
             raise ValueError(
-                "when sending a str, it must be a hex string. Got: {0!r}".format(
-                    hexstr_or_primitive
-                )
+                "when sending a str, it must be a hex string. "
+                f"Got: {repr(hexstr_or_primitive)}"
             )
         return to_type(hexstr=hexstr_or_primitive)
     else:

faster_eth_utils/crypto.py

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