faster-eth-utils 5.3.17__cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl

faster_eth_utils/currency.py

@@ -0,0 +1,141 @@
+import decimal
+from decimal import (
+    localcontext,
+)
+from typing import (
+    Final,
+    Union,
+    final,
+)
+
+from .types import (
+    is_integer,
+    is_string,
+)
+from .units import (
+    units,
+)
+
+
+@final
+class denoms:
+    wei: Final = int(units["wei"])
+    kwei: Final = int(units["kwei"])
+    babbage: Final = int(units["babbage"])
+    femtoether: Final = int(units["femtoether"])
+    mwei: Final = int(units["mwei"])
+    lovelace: Final = int(units["lovelace"])
+    picoether: Final = int(units["picoether"])
+    gwei: Final = int(units["gwei"])
+    shannon: Final = int(units["shannon"])
+    nanoether: Final = int(units["nanoether"])
+    nano: Final = int(units["nano"])
+    szabo: Final = int(units["szabo"])
+    microether: Final = int(units["microether"])
+    micro: Final = int(units["micro"])
+    finney: Final = int(units["finney"])
+    milliether: Final = int(units["milliether"])
+    milli: Final = int(units["milli"])
+    ether: Final = int(units["ether"])
+    kether: Final = int(units["kether"])
+    grand: Final = int(units["grand"])
+    mether: Final = int(units["mether"])
+    gether: Final = int(units["gether"])
+    tether: Final = int(units["tether"])
+
+
+MIN_WEI: Final = 0
+MAX_WEI: Final = 2**256 - 1
+
+_NumberType = Union[int, float, str, decimal.Decimal]
+
+
+def _from_wei(number: int, unit_value: decimal.Decimal) -> Union[int, decimal.Decimal]:
+    if number == 0:
+        return 0
+
+    if number < MIN_WEI or number > MAX_WEI:
+        raise ValueError("value must be between 0 and 2**256 - 1")
+
+    with localcontext() as ctx:
+        ctx.prec = 999
+        d_number = decimal.Decimal(value=number, context=ctx)
+        result_value = d_number / unit_value
+
+    return result_value
+
+
+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):
+        d_number = decimal.Decimal(value=str(number))
+    elif isinstance(number, decimal.Decimal):
+        d_number = number
+    else:
+        raise TypeError("Unsupported type. Must be one of integer, float, or string")
+
+    if d_number == decimal.Decimal(0):
+        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
+            ctx.prec = multiplier
+            d_number = decimal.Decimal(value=number, context=ctx) * 10**multiplier  # type: ignore [arg-type]
+        unit_value /= 10**multiplier
+
+    with localcontext() as ctx:
+        ctx.prec = 999
+        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 0 and 2**256 - 1")
+
+    return int(result_value)
+
+
+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())}")
+
+    unit_value = units[unit.lower()]
+
+    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.
+    """
+    if unit.lower() not in units:
+        raise ValueError(f"Unknown unit. Must be one of {'/'.join(units.keys())}")
+
+    unit_value = units[unit.lower()]
+
+    return _to_wei(number, unit_value)
+
+
+def from_wei_decimals(number: int, decimals: int) -> Union[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)

faster_eth_utils/curried/__init__.py

@@ -0,0 +1,306 @@
+import sys
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Generator,
+    Optional,
+    Sequence,
+    Tuple,
+    TypeVar,
+    Union,
+    overload,
+)
+from typing_extensions import TypeGuard
+
+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:
+    if sys.version_info >= (3, 9):
+        from _typeshed import SupportsBool
+    # We have to sacrifice a little bit of specificity on dinosaur Python3.8
+    else:
+        SupportsBool = Any
+
+
+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], Union[TReturn, TArg]]]:
+    ...
+
+@overload
+def apply_formatter_if(
+    condition: Callable[[TArg], TypeGuard[TOther]], formatter: Callable[[TOther], TReturn]
+) -> Callable[[TArg], Union[TReturn, TArg]]:
+    ...
+
+@overload
+def apply_formatter_if(
+    condition: Callable[[TArg], TypeGuard[TOther]], formatter: Callable[[TOther], TReturn], value: TArg
+) -> Union[TReturn, TArg]:
+    ...
+
+@overload
+def apply_formatter_if(
+    condition: Callable[[TArg], bool], formatter: Callable[[TArg], TReturn], value: TArg
+) -> Union[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,
+]:
+    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(
+    formatter_condition_pairs: Sequence[
+        Tuple[Callable[[TArg], "SupportsBool"], Callable[[TArg], TReturn]]
+    ],
+    value: Optional[TArg] = None,
+) -> TReturn: ...
+
+
+@overload
+def hexstr_if_str(
+    to_type: Callable[..., TReturn],
+) -> Callable[[Union[bytes, int, str]], TReturn]: ...
+
+
+@overload
+def hexstr_if_str(
+    to_type: Callable[..., TReturn], to_format: Union[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: ...
+
+
+@overload
+def text_if_str(
+    to_type: Callable[..., TReturn],
+) -> Callable[[Union[bytes, int, str]], TReturn]: ...
+
+
+@overload
+def text_if_str(
+    to_type: Callable[..., TReturn], text_or_primitive: Union[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: ...
+
+
+@overload
+def apply_formatters_to_dict(
+    formatters: Dict[Any, Any], unaliased: bool = False
+) -> Callable[[Union[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]:
+    ...
+
+
+# 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,
+    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 Dict
+del Generator
+del Optional
+del Sequence
+del TReturn
+del TValue
+del Tuple
+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,119 @@
+import functools
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Final,
+    Generic,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    final,
+)
+
+from typing_extensions import Concatenate, 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[Union[TInstance, Type[TInstance]], P], T]
+    ) -> None:
+        self.method: Final = method
+
+    def __repr__(self) -> str:
+        return f"combomethod({self.method})"
+
+    def __get__(
+        self,
+        obj: Optional[TInstance],
+        objtype: Type[TInstance],
+    ) -> Callable[P, T]:
+
+        @functools.wraps(self.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 _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) -> 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):
+    """
+    Raised when something does not pass a validation check.
+    """

faster_eth_utils/functional.py

@@ -0,0 +1,89 @@
+import collections
+import functools
+import itertools
+from typing import (  # noqa: F401
+    Callable,
+    Dict,
+    Iterable,
+    List,
+    Mapping,
+    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, 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]:
+        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)