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

faster_eth_utils/currency.py

@@ -1,9 +1,20 @@
 import decimal
-from decimal import localcontext
-from typing import Final, Union, final
-
-from .types import is_integer, is_string
-from .units import units
+from decimal import (
+    localcontext,
+)
+from typing import (
+    Final,
+    Union,
+    final,
+)
+
+from .types import (
+    is_integer,
+    is_string,
+)
+from .units import (
+    units,
+)
 
 
 @final
@@ -36,23 +47,15 @@ class denoms:
 MIN_WEI: Final = 0
 MAX_WEI: Final = 2**256 - 1
 
+_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(
-            "Unknown unit.  Must be one of {0}".format("/".join(units.keys()))
-        )
 
+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 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
@@ -62,35 +65,26 @@ 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(
-            "Unknown unit.  Must be one of {0}".format("/".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)
+        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")
-
-    s_number = str(number)
-    unit_value = units[unit.lower()]
+        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
+            d_number = decimal.Decimal(value=number, context=ctx) * 10**multiplier  # type: ignore [arg-type]
         unit_value /= 10**multiplier
 
     with localcontext() as ctx:
@@ -98,6 +92,50 @@ 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) -> 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

@@ -1,5 +1,6 @@
-# flake8: noqa
+import sys
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
     Dict,
@@ -11,8 +12,10 @@ from typing import (
     Union,
     overload,
 )
+from typing_extensions import TypeGuard
 
 from faster_eth_utils import (
+    CamelModel,
     ExtendedDebugLogger,
     HasExtendedDebugLogger,
     HasExtendedDebugLoggerMeta,
@@ -20,13 +23,19 @@ from faster_eth_utils import (
     HasLoggerMeta,
     Network,
     ValidationError,
+    abi_to_signature,
     add_0x_prefix,
     apply_formatter_at_index,
-)
-from faster_eth_utils import (
+    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,
@@ -34,16 +43,27 @@ from faster_eth_utils import (
     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,
-)
-from faster_eth_utils import (
+    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,
@@ -81,8 +101,7 @@ from faster_eth_utils import (
     setup_DEBUG2_logging,
     short_name_from_chain_id,
     sort_return,
-)
-from faster_eth_utils import (
+    text_if_str as non_curried_text_if_str,
     to_bytes,
     to_canonical_address,
     to_checksum_address,
@@ -96,166 +115,176 @@ from faster_eth_utils import (
     to_text,
     to_tuple,
     to_wei,
+    to_wei_decimals,
 )
-from faster_eth_utils import apply_formatter_if as non_curried_apply_formatter_if
-from faster_eth_utils import apply_formatter_to_array
-from faster_eth_utils import apply_formatters_to_dict as non_curried_apply_formatters_to_dict
-from faster_eth_utils import apply_formatters_to_sequence, apply_key_map
-from faster_eth_utils import apply_one_of_formatters as non_curried_apply_one_of_formatters
-from faster_eth_utils import hexstr_if_str as non_curried_hexstr_if_str
-from faster_eth_utils import text_if_str as non_curried_text_if_str
-from faster_eth_utils.toolz import curry
+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[..., bool]
-) -> Callable[[Callable[..., TReturn]], Callable[[TValue], Union[TReturn, TValue]]]:
+    condition: Callable[[TArg], TypeGuard[TOther]],
+) -> Callable[[Callable[[TOther], TReturn]], Callable[[TArg], Union[TReturn, TArg]]]:
     ...
 
-
 @overload
 def apply_formatter_if(
-    condition: Callable[..., bool], formatter: Callable[..., TReturn]
-) -> Callable[[TValue], Union[TReturn, TValue]]:
+    condition: Callable[[TArg], TypeGuard[TOther]], formatter: Callable[[TOther], TReturn]
+) -> Callable[[TArg], Union[TReturn, TArg]]:
     ...
 
-
 @overload
 def apply_formatter_if(
-    condition: Callable[..., bool], formatter: Callable[..., TReturn], value: TValue
-) -> Union[TReturn, TValue]:
+    condition: Callable[[TArg], TypeGuard[TOther]], formatter: Callable[[TOther], TReturn], value: TArg
+) -> Union[TReturn, TArg]:
     ...
 
-
-# This is just a stub to appease mypy, it gets overwritten later
+@overload
 def apply_formatter_if(
-    condition: Callable[..., bool],
-    formatter: Callable[..., TReturn] = None,
-    value: TValue = None,
+    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[..., TReturn]], Callable[[TValue], Union[TReturn, TValue]]],
-    Callable[[TValue], Union[TReturn, TValue]],
+    Callable[[Callable[[TOther], TReturn]], Callable[[TArg], Union[TReturn, TArg]]],
+    Callable[[TArg], Union[TReturn, TArg]],
     TReturn,
-    TValue,
+    TArg,
 ]:
-    ...
+    pass
 
 
 @overload
 def apply_one_of_formatters(
     formatter_condition_pairs: Sequence[
-        Tuple[Callable[..., bool], Callable[..., TReturn]]
-    ]
-) -> Callable[[TValue], TReturn]:
-    ...
+        Tuple[Callable[[TArg], "SupportsBool"], Callable[[TArg], 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(
     formatter_condition_pairs: Sequence[
-        Tuple[Callable[..., bool], Callable[..., TReturn]]
+        Tuple[Callable[[TArg], "SupportsBool"], Callable[[TArg], TReturn]]
     ],
-    value: TValue = None,
-) -> TReturn:
-    ...
+    value: Optional[TArg] = None,
+) -> TReturn: ...
 
 
 @overload
 def hexstr_if_str(
-    to_type: Callable[..., TReturn]
-) -> Callable[[Union[bytes, int, str]], TReturn]:
-    ...
+    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:
-    ...
+) -> TReturn: ...
 
 
 # This is just a stub to appease mypy, it gets overwritten later
-def hexstr_if_str(
-    to_type: Callable[..., TReturn], to_format: Union[bytes, int, str] = None
-) -> TReturn:
-    ...
+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]:
-    ...
+    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:
-    ...
+) -> TReturn: ...
 
 
 # This is just a stub to appease mypy, it gets overwritten later
-def text_if_str(
-    to_type: Callable[..., TReturn], text_or_primitive: Union[bytes, int, str] = None
-) -> TReturn:
-    ...
+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]
-) -> Callable[[Dict[Any, Any]], TReturn]:
+    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: Dict[Any, Any]
-) -> TReturn:
+    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[Dict[Any, Any]] = None
-) -> TReturn:
-    ...
+    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)
+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)
+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)
+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)
-hexstr_if_str = curry(non_curried_hexstr_if_str)
+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)
-text_if_str = curry(non_curried_text_if_str)
+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 *`
+# `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
@@ -265,6 +294,7 @@ del Sequence
 del TReturn
 del TValue
 del Tuple
+del TypeGuard
 del TypeVar
 del Union
 del curry

faster_eth_utils/debug.py

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

faster_eth_utils/decorators.py

@@ -1,56 +1,107 @@
 import functools
-import itertools
-from typing import Any, Callable, Dict, Type, TypeVar, final
-
-from .types import is_text
+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(object):
-    def __init__(self, method: Callable[..., Any]) -> None:
-        self.method = method
+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]:
 
-    def __get__(self, obj: T = None, objtype: Type[T] = None) -> Callable[..., Any]:
         @functools.wraps(self.method)
-        def _wrapper(*args: Any, **kwargs: Any) -> Any:
+        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)
+                return self.method(objtype, *args, **kwargs)  # type: ignore [arg-type]
 
         return _wrapper
 
 
-def return_arg_type(at_position: int) -> Callable[..., Callable[..., T]]:
+_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[..., Any]) -> Callable[..., T]:
+    def decorator(to_wrap: Callable[P, Any]) -> Callable[P, Any]:
         @functools.wraps(to_wrap)
-        def wrapper(*args: Any, **kwargs: Any) -> T:
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> Any:
             result = to_wrap(*args, **kwargs)
             ReturnType = type(args[at_position])
-            return ReturnType(result)  # type: ignore
+            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[Type[BaseException], Type[BaseException]]
-) -> Callable[[Callable[..., T]], Callable[..., T]]:
+    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.
     """
-    old_exceptions = tuple(old_to_new_exceptions.keys())
+    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[..., T]) -> Callable[..., T]:
+    def decorator(to_wrap: Callable[P, T]) -> Callable[P, T]:
         @functools.wraps(to_wrap)
-        def wrapped(*args: Any, **kwargs: Any) -> T:
+        def wrapped(*args: P.args, **kwargs: P.kwargs) -> T:
             try:
                 return to_wrap(*args, **kwargs)
             except old_exceptions as err:
@@ -58,9 +109,11 @@ def replace_exceptions(
                     raise old_to_new_exceptions[type(err)](err) from err
                 except KeyError:
                     raise TypeError(
-                        "could not look up new exception to use for %r" % err
+                        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/exceptions.py

@@ -1,6 +1,11 @@
-class ValidationError(Exception):
+"""
+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.
     """
-
-    pass