faster-eth-utils 5.3.22__cp312-cp312-musllinux_1_2_x86_64.whl

faster_eth_utils/curried/__init__.py

@@ -0,0 +1,297 @@
+import sys
+from collections.abc import Callable, Generator, Sequence
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Optional,
+    TypeGuard,
+    TypeVar,
+    Union,
+    overload,
+)
+
+from faster_eth_utils import (
+    CamelModel,
+    ExtendedDebugLogger,
+    HasExtendedDebugLogger,
+    HasExtendedDebugLoggerMeta,
+    HasLogger,
+    HasLoggerMeta,
+    Network,
+    ValidationError,
+    abi_to_signature,
+    add_0x_prefix,
+    apply_formatter_at_index,
+    apply_formatter_if as non_curried_apply_formatter_if,
+    apply_formatter_to_array,
+    apply_formatters_to_dict as non_curried_apply_formatters_to_dict,
+    apply_formatters_to_sequence,
+    apply_key_map,
+    apply_one_of_formatters as non_curried_apply_one_of_formatters,
+    apply_to_return_value,
+    big_endian_to_int,
+    clamp,
+    collapse_if_tuple,
+    combine_argument_formatters,
+    combomethod,
+    decode_hex,
+    denoms,
+    encode_hex,
+    event_abi_to_log_topic,
+    event_signature_to_log_topic,
+    filter_abi_by_name,
+    filter_abi_by_type,
+    flatten_return,
+    from_wei,
+    from_wei_decimals,
+    function_abi_to_4byte_selector,
+    function_signature_to_4byte_selector,
+    get_abi_input_names,
+    get_abi_input_types,
+    get_abi_output_names,
+    get_abi_output_types,
+    get_aligned_abi_inputs,
+    get_all_event_abis,
+    get_all_function_abis,
+    get_extended_debug_logger,
+    get_logger,
+    get_normalized_abi_inputs,
+    hexstr_if_str as non_curried_hexstr_if_str,
+    humanize_bytes,
+    humanize_hash,
+    humanize_hexstr,
+    humanize_integer_sequence,
+    humanize_ipfs_uri,
+    humanize_seconds,
+    humanize_wei,
+    import_string,
+    int_to_big_endian,
+    is_0x_prefixed,
+    is_address,
+    is_binary_address,
+    is_boolean,
+    is_bytes,
+    is_canonical_address,
+    is_checksum_address,
+    is_checksum_formatted_address,
+    is_dict,
+    is_hex,
+    is_hex_address,
+    is_hexstr,
+    is_integer,
+    is_list,
+    is_list_like,
+    is_normalized_address,
+    is_null,
+    is_number,
+    is_same_address,
+    is_string,
+    is_text,
+    is_tuple,
+    keccak,
+    name_from_chain_id,
+    network_from_chain_id,
+    remove_0x_prefix,
+    replace_exceptions,
+    reversed_return,
+    setup_DEBUG2_logging,
+    short_name_from_chain_id,
+    sort_return,
+    text_if_str as non_curried_text_if_str,
+    to_bytes,
+    to_canonical_address,
+    to_checksum_address,
+    to_dict,
+    to_hex,
+    to_int,
+    to_list,
+    to_normalized_address,
+    to_ordered_dict,
+    to_set,
+    to_text,
+    to_tuple,
+    to_wei,
+    to_wei_decimals,
+)
+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[[TArg], TypeGuard[TOther]],
+) -> Callable[[Callable[[TOther], TReturn]], Callable[[TArg], TReturn | TArg]]:
+    ...
+
+@overload
+def apply_formatter_if(
+    condition: Callable[[TArg], TypeGuard[TOther]], formatter: Callable[[TOther], TReturn]
+) -> Callable[[TArg], TReturn | TArg]:
+    ...
+
+@overload
+def apply_formatter_if(
+    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:
+    ...
+
+def apply_formatter_if(  # type: ignore
+    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]]
+    ],
+) -> Callable[[TArg], TReturn]: ...
+
+
+@overload
+def apply_one_of_formatters(
+    formatter_condition_pairs: Sequence[
+        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(  # type: ignore[empty-body]
+    formatter_condition_pairs: Sequence[
+        tuple[Callable[[TArg], "SupportsBool"], Callable[[TArg], TReturn]]
+    ],
+    value: TArg | None = None,
+) -> Callable[[TArg], TReturn] | TReturn: ...
+
+
+@overload
+def hexstr_if_str(
+    to_type: Callable[..., TReturn],
+) -> Callable[[bytes | int | str], TReturn]: ...
+
+
+@overload
+def hexstr_if_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: bytes | int | str | None = None
+) -> TReturn: ...
+
+
+@overload
+def text_if_str(
+    to_type: Callable[..., TReturn],
+) -> Callable[[bytes | int | str], TReturn]: ...
+
+
+@overload
+def text_if_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: bytes | int | str | None = None,
+) -> TReturn: ...
+
+
+@overload
+def apply_formatters_to_dict(
+    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: 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: dict[Any, Any] | CamelModel | None = None,
+    unaliased: bool = False,
+) -> dict[Any, Any]: ...
+
+
+apply_formatter_at_index = curry(apply_formatter_at_index)
+apply_formatter_if = curry(non_curried_apply_formatter_if)  # noqa: F811
+apply_formatter_to_array = curry(apply_formatter_to_array)
+apply_formatters_to_dict = curry(non_curried_apply_formatters_to_dict)  # noqa: F811
+apply_formatters_to_sequence = curry(apply_formatters_to_sequence)
+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)
+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)
+
+# Delete any methods and classes that are not intended to be importable from
+# `eth_utils.curried`. We do this approach instead of __all__ because this approach
+# actually prevents importing the wrong thing, while __all__ only affects
+# `from eth_utils.curried import *`
+del Any
+del Callable
+del Generator
+del Optional
+del Sequence
+del TReturn
+del TValue
+del TypeGuard
+del TypeVar
+del Union
+del curry
+del non_curried_apply_formatter_if
+del non_curried_apply_one_of_formatters
+del non_curried_apply_formatters_to_dict
+del non_curried_hexstr_if_str
+del non_curried_text_if_str
+del overload

faster_eth_utils/debug.py

@@ -0,0 +1,20 @@
+import platform
+import subprocess
+import sys
+
+
+def pip_freeze() -> str:
+    result = subprocess.run("python -m pip freeze".split(), stdout=subprocess.PIPE)
+    return f"python -m pip freeze result:\n{result.stdout.decode()}"
+
+
+def python_version() -> str:
+    return f"Python version:\n{sys.version}"
+
+
+def platform_info() -> str:
+    return f"Operating System: {platform.platform()}"
+
+
+def get_environment_summary() -> str:
+    return "\n\n".join([python_version(), platform_info(), pip_freeze()])

faster_eth_utils/decorators.py

@@ -0,0 +1,115 @@
+import functools
+from collections.abc import Callable
+from typing import (
+    Any,
+    Concatenate,
+    Final,
+    Generic,
+    TypeVar,
+    final,
+)
+
+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(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: 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
+
+
+_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[P, Any]) -> Callable[P, Any]:
+        @functools.wraps(to_wrap)
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> Any:
+            result = to_wrap(*args, **kwargs)
+            ReturnType = type(args[at_position])
+            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[ExcType, ExcType],
+) -> Callable[[Callable[P, T]], Callable[P, T]]:
+    """
+    Replaces old exceptions with new exceptions to be raised in their place.
+    """
+    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[P, T]) -> Callable[P, T]:
+        @functools.wraps(to_wrap)
+        def wrapped(*args: P.args, **kwargs: P.kwargs) -> T:
+            try:
+                return to_wrap(*args, **kwargs)
+            except old_exceptions as err:
+                try:
+                    raise old_to_new_exceptions[type(err)](err) from err
+                except KeyError:
+                    raise TypeError(
+                        f"could not look up new exception to use for {repr(err)}"
+                    ) from err
+
+        return wrapped
+
+    _replace_exceptions_deco_cache[cache_key] = decorator
+
+    return decorator

faster_eth_utils/encoding.py

@@ -0,0 +1,6 @@
+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 | bytearray) -> int:
+    return int.from_bytes(value, "big")

faster_eth_utils/exceptions.py

@@ -0,0 +1,11 @@
+"""
+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

@@ -0,0 +1,87 @@
+import collections
+import functools
+import itertools
+from collections.abc import Callable, Iterable, Mapping
+from typing import (  # noqa: F401
+    Dict,
+    List,
+    Set,
+    Tuple,
+    TypeVar,
+    Union,
+)
+
+from typing_extensions import ParamSpec
+
+from .toolz import (
+    compose as _compose,
+)
+
+P = ParamSpec("P")
+T = TypeVar("T")
+
+
+def identity(value: T) -> T:
+    return value
+
+
+TGIn = TypeVar("TGIn")
+TGOut = TypeVar("TGOut")
+TFOut = TypeVar("TFOut")
+
+
+def combine(
+    f: Callable[[TGOut], TFOut], g: Callable[[TGIn], TGOut]
+) -> Callable[[TGIn], TFOut]:
+    def combined(x: TGIn) -> TFOut:
+        return f(g(x))
+    return combined
+
+
+TCb = TypeVar("TCb")
+
+
+def apply_to_return_value(
+    callback: Callable[[T], TCb]
+) -> Callable[[Callable[P, T]], Callable[P, TCb]]:
+    def outer(fn: Callable[P, T]) -> Callable[P, TCb]:
+        @functools.wraps(fn)
+        def inner(*args: P.args, **kwargs: P.kwargs) -> TCb:
+            return callback(fn(*args, **kwargs))
+        return inner
+    return outer
+
+
+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, ...]:
+        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]:
+        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]:
+        return set(fn(*args, **kwargs))
+    return to_set_wrap
+
+def to_dict(
+    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
+
+to_ordered_dict = apply_to_return_value(  # type: ignore [assignment]
+    collections.OrderedDict
+)  # type: Callable[[Callable[P, Union[Mapping[TKey, TVal], Iterable[Tuple[TKey, TVal]]]]], Callable[P, collections.OrderedDict[TKey, TVal]]]  # noqa: E501
+sort_return = _compose(to_tuple, apply_to_return_value(sorted))
+flatten_return = _compose(
+    to_tuple, apply_to_return_value(itertools.chain.from_iterable)
+)
+reversed_return = _compose(to_tuple, apply_to_return_value(reversed), to_tuple)

faster_eth_utils/hexadecimal.py

@@ -0,0 +1,76 @@
+# String encodings and numeric representations
+
+import binascii
+import re
+from typing import (
+    Any,
+    Final,
+    TypeGuard,
+)
+
+from eth_typing import (
+    HexStr,
+)
+
+_HEX_REGEXP_MATCH: Final = re.compile("(0[xX])?[0-9a-fA-F]*").fullmatch
+
+_hexlify: Final = binascii.hexlify
+_unhexlify: Final = binascii.unhexlify
+
+
+
+def decode_hex(value: str) -> bytes:
+    if not isinstance(value, str):
+        raise TypeError("Value must be an instance of str")
+    non_prefixed = remove_0x_prefix(HexStr(value))
+    # unhexlify will only accept bytes type someday
+    ascii_hex = non_prefixed.encode("ascii")
+    return _unhexlify(ascii_hex)
+
+
+def encode_hex(value: str | bytes | bytearray) -> HexStr:
+    ascii_bytes: bytes | bytearray
+    if isinstance(value, (bytes, bytearray)):
+        ascii_bytes = value
+    elif isinstance(value, str):
+        ascii_bytes = value.encode("ascii")
+    else:
+        raise TypeError("Value must be an instance of str or unicode")
+
+    binary_hex = _hexlify(ascii_bytes)
+    return add_0x_prefix(HexStr(binary_hex.decode("ascii")))
+
+
+def is_0x_prefixed(value: str) -> bool:
+    # this check is not needed in the compiled version
+    # if not isinstance(value, str):
+    #     raise TypeError(
+    #         f"is_0x_prefixed requires text typed arguments. Got: {repr(value)}"
+    #     )
+    return value.startswith("0x") or value.startswith("0X")
+
+
+def remove_0x_prefix(value: HexStr) -> HexStr:
+    if is_0x_prefixed(value):
+        return HexStr(value[2:])
+    return value
+
+
+def add_0x_prefix(value: HexStr) -> HexStr:
+    if is_0x_prefixed(value):
+        return value
+    return HexStr("0x" + value)
+
+
+def is_hexstr(value: Any) -> TypeGuard[HexStr]:
+    if not isinstance(value, str) or not value:
+        return False
+    return _HEX_REGEXP_MATCH(value) is not None
+
+
+def is_hex(value: Any) -> TypeGuard[HexStr]:
+    if not isinstance(value, str):
+        raise TypeError(f"is_hex requires text typed arguments. Got: {repr(value)}")
+    if not value:
+        return False
+    return _HEX_REGEXP_MATCH(value) is not None