faster-eth-utils 5.3.8__cp313-cp313-win_amd64.whl → 5.3.23__cp313-cp313-win_amd64.whl

faster_eth_utils/abi.py

@@ -1,20 +1,17 @@
-from collections import (
-    abc,
-)
 import copy
 import itertools
 import re
-from typing import (
-    Any,
-    Dict,
+from collections.abc import (
     Iterable,
-    List,
-    Literal,
     Mapping,
-    Optional,
     Sequence,
-    Tuple,
-    Union,
+)
+from typing import (
+    Any,
+    Final,
+    Generic,
+    Literal,
+    TypeVar,
     cast,
     overload,
 )
@@ -30,6 +27,9 @@ from eth_typing import (
     ABIFunction,
     ABIReceive,
 )
+from typing_extensions import (
+    Self,
+)
 
 from faster_eth_utils.types import (
     is_list_like,
@@ -40,9 +40,37 @@ from .crypto import (
 )
 
 
+T = TypeVar("T")
+
+ABIType = Literal["function", "constructor", "fallback", "receive", "event", "error"]
+
+_TUPLE_TYPE_STR_RE: Final = re.compile("^(tuple)((\\[([1-9]\\d*\\b)?])*)??$")
+
+_chain: Final = itertools.chain
+
+
+class _repeat(Generic[T]):
+
+    def __init__(self, value: T, times: int | None = None) -> None:
+        self._value: Final[T] = value
+        self._times: Final[int | None] = times
+        self._index = 0
+
+    def __iter__(self) -> Self:
+        return self
+
+    def __next__(self) -> T:
+        if self._times is None:
+            return self._value
+        if self._index >= self._times:
+            raise StopIteration
+        self._index += 1
+        return self._value
+
+
 def _align_abi_input(
     arg_abi: ABIComponent, normalized_arg: Any
-) -> Union[Any, Tuple[Any, ...]]:
+) -> Any | tuple[Any, ...]:
     """
     Aligns the values of any mapping at any level of nesting in ``normalized_arg``
     according to the layout of the corresponding abi spec.
@@ -66,37 +94,38 @@ def _align_abi_input(
         new_abi = copy.copy(arg_abi)
         new_abi["type"] = tuple_prefix + "[]" * (num_dims - 1)
 
-        sub_abis = itertools.repeat(new_abi)
+        sub_abis = _repeat(new_abi)
 
     aligned_arg: Any
-    if isinstance(normalized_arg, abc.Mapping):
+    if isinstance(normalized_arg, Mapping):
         # normalized_arg is mapping.  Align values according to abi order.
         aligned_arg = tuple(normalized_arg[abi["name"]] for abi in sub_abis)
     else:
         aligned_arg = normalized_arg
 
-    if not is_list_like(aligned_arg):
-        raise TypeError(
-            f'Expected non-string sequence for "{arg_abi.get("type")}" '
-            f"component type: got {aligned_arg}"
-        )
+    # We can generate more optimized C code if we branch by arg type
+    if isinstance(aligned_arg, tuple):
+        # convert NamedTuple to regular tuple
+        return tuple(map(_align_abi_input, sub_abis, aligned_arg))
 
-    # convert NamedTuple to regular tuple
-    typing = tuple if isinstance(aligned_arg, tuple) else type(aligned_arg)
+    elif type(aligned_arg) is list:
+        return list(map(_align_abi_input, sub_abis, aligned_arg))
 
-    return typing(  # type: ignore [call-arg]
-        _align_abi_input(sub_abi, sub_arg)
-        for sub_abi, sub_arg in zip(sub_abis, aligned_arg)
+    elif is_list_like(aligned_arg):
+        return type(aligned_arg)(map(_align_abi_input, sub_abis, aligned_arg))  # type: ignore [call-arg]
+
+    raise TypeError(
+        f'Expected non-string sequence for "{arg_abi.get("type")}" '
+        f"component type: got {aligned_arg}"
     )
 
 
-def _get_tuple_type_str_and_dims(s: str) -> Optional[Tuple[str, Optional[str]]]:
+def _get_tuple_type_str_and_dims(s: str) -> tuple[str, str | None] | None:
     """
     Takes a JSON ABI type string.  For tuple type strings, returns the separated
     prefix and array dimension parts.  For all other strings, returns ``None``.
     """
-    tuple_type_str_re = "^(tuple)((\\[([1-9]\\d*\b)?])*)??$"
-    match = re.compile(tuple_type_str_re).match(s)
+    match = _TUPLE_TYPE_STR_RE.match(s)
 
     return None if match is None else (match[1], match[2])
 
@@ -119,7 +148,7 @@ def _raise_if_fallback_or_receive_abi(abi_element: ABIElement) -> None:
         )
 
 
-def collapse_if_tuple(abi: Union[ABIComponent, Dict[str, Any], str]) -> str:
+def collapse_if_tuple(abi: ABIComponent | dict[str, Any] | str) -> str:
     """
     Extract argument types from a function or event ABI parameter.
 
@@ -278,11 +307,21 @@ def filter_abi_by_name(abi_name: str, contract_abi: ABI) -> Sequence[ABIElement]
     ]
 
 
+__ABI_TYPE_LITERALS: Final  = {
+    Literal["function"]: "function",
+    Literal["constructor"]: "constructor",
+    Literal["fallback"]: "fallback",
+    Literal["receive"]: "receive",
+    Literal["event"]: "event",
+    Literal["error"]: "error",
+}
+
+
 @overload
 def filter_abi_by_type(
     abi_type: Literal["function"],
     contract_abi: ABI,
-) -> List[ABIFunction]:
+) -> list[ABIFunction]:
     pass
 
 
@@ -290,7 +329,7 @@ def filter_abi_by_type(
 def filter_abi_by_type(
     abi_type: Literal["constructor"],
     contract_abi: ABI,
-) -> List[ABIConstructor]:
+) -> list[ABIConstructor]:
     pass
 
 
@@ -298,7 +337,7 @@ def filter_abi_by_type(
 def filter_abi_by_type(
     abi_type: Literal["fallback"],
     contract_abi: ABI,
-) -> List[ABIFallback]:
+) -> list[ABIFallback]:
     pass
 
 
@@ -306,7 +345,7 @@ def filter_abi_by_type(
 def filter_abi_by_type(
     abi_type: Literal["receive"],
     contract_abi: ABI,
-) -> List[ABIReceive]:
+) -> list[ABIReceive]:
     pass
 
 
@@ -314,7 +353,7 @@ def filter_abi_by_type(
 def filter_abi_by_type(
     abi_type: Literal["event"],
     contract_abi: ABI,
-) -> List[ABIEvent]:
+) -> list[ABIEvent]:
     pass
 
 
@@ -322,18 +361,16 @@ def filter_abi_by_type(
 def filter_abi_by_type(
     abi_type: Literal["error"],
     contract_abi: ABI,
-) -> List[ABIError]:
+) -> list[ABIError]:
     pass
 
 
 def filter_abi_by_type(
-    abi_type: Literal[
-        "function", "constructor", "fallback", "receive", "event", "error"
-    ],
+    abi_type: ABIType,
     contract_abi: ABI,
-) -> Union[
-    List[ABIFunction], List[ABIConstructor], List[ABIFallback], List[ABIReceive], List[ABIEvent], List[ABIError]
-]:
+) -> (
+    list[ABIFunction] | list[ABIConstructor] | list[ABIFallback] | list[ABIReceive] | list[ABIEvent] | list[ABIError]
+):
     """
     Return a list of each ``ABIElement`` that is of type ``abi_type``.
 
@@ -361,20 +398,12 @@ ABIEvent, ABIError]]`
         [{'type': 'function', 'name': 'myFunction', 'inputs': [], 'outputs': []}, \
 {'type': 'function', 'name': 'myFunction2', 'inputs': [], 'outputs': []}]
     """
-    if abi_type == Literal["function"] or abi_type == "function":
-        return [abi for abi in contract_abi if abi["type"] == "function"]
-    elif abi_type == Literal["constructor"] or abi_type == "constructor":
-        return [abi for abi in contract_abi if abi["type"] == "constructor"]
-    elif abi_type == Literal["fallback"] or abi_type == "fallback":
-        return [abi for abi in contract_abi if abi["type"] == "fallback"]
-    elif abi_type == Literal["receive"] or abi_type == "receive":
-        return [abi for abi in contract_abi if abi["type"] == "receive"]
-    elif abi_type == Literal["event"] or abi_type == "event":
-        return [abi for abi in contract_abi if abi["type"] == "event"]
-    elif abi_type == Literal["error"] or abi_type == "error":
-        return [abi for abi in contract_abi if abi["type"] == "error"]
-    else:
+    if abi_type in ("function", "constructor", "fallback", "receive", "event", "error"):
+        return [abi for abi in contract_abi if abi["type"] == abi_type]  # type: ignore [return-value]
+    abi_type_string: ABIType | None = __ABI_TYPE_LITERALS.get(abi_type)  # type: ignore [call-overload]
+    if abi_type_string is None:
         raise ValueError(f"Unsupported ABI type: {abi_type}")
+    return [abi for abi in contract_abi if abi["type"] == abi_type_string]  # type: ignore [return-value]    
 
 
 def get_all_function_abis(contract_abi: ABI) -> Sequence[ABIFunction]:
@@ -428,7 +457,7 @@ def get_normalized_abi_inputs(
     abi_element: ABIElement,
     *args: Any,
     **kwargs: Any,
-) -> Tuple[Any, ...]:
+) -> tuple[Any, ...]:
     r"""
     Flattens positional args (``args``) and keyword args (``kwargs``) into a Tuple and
     uses the ``abi_element`` for validation.
@@ -496,6 +525,7 @@ def get_normalized_abi_inputs(
 
     kwarg_names = set(kwargs.keys())
     sorted_arg_names = tuple(arg_abi["name"] for arg_abi in function_inputs)
+    arg_positions = {name: index for index, name in enumerate(sorted_arg_names)}
     args_as_kwargs = dict(zip(sorted_arg_names, args))
 
     # Check for duplicate args
@@ -521,22 +551,17 @@ def get_normalized_abi_inputs(
 
     # Sort args according to their position in the ABI and unzip them from their
     # names
-    sorted_args = tuple(
-        zip(
-            *sorted(
-                itertools.chain(kwargs.items(), args_as_kwargs.items()),
-                key=lambda kv: sorted_arg_names.index(kv[0]),
-            )
-        )
+    sorted_items = sorted(
+        _chain(kwargs.items(), args_as_kwargs.items()),
+        key=lambda kv: arg_positions[kv[0]],
     )
-
-    return tuple(sorted_args[1]) if sorted_args else ()
+    return tuple(val for _, val in sorted_items)
 
 
 def get_aligned_abi_inputs(
     abi_element: ABIElement,
-    normalized_args: Union[Tuple[Any, ...], Mapping[Any, Any]],
-) -> Tuple[Tuple[str, ...], Tuple[Any, ...]]:
+    normalized_args: tuple[Any, ...] | Mapping[Any, Any],
+) -> tuple[tuple[str, ...], tuple[Any, ...]]:
     """
     Returns a pair of nested Tuples containing a list of types and a list of input
     values sorted by the order specified by the ``abi``.
@@ -579,7 +604,7 @@ def get_aligned_abi_inputs(
     _raise_if_fallback_or_receive_abi(abi_element)
 
     abi_element_inputs = cast(Sequence[ABIComponent], abi_element.get("inputs", []))
-    if isinstance(normalized_args, abc.Mapping):
+    if isinstance(normalized_args, Mapping):
         # `args` is mapping.  Align values according to abi order.
         normalized_args = tuple(
             normalized_args[abi["name"]] for abi in abi_element_inputs
@@ -594,7 +619,7 @@ def get_aligned_abi_inputs(
     )
 
 
-def get_abi_input_names(abi_element: ABIElement) -> List[Optional[str]]:
+def get_abi_input_names(abi_element: ABIElement) -> list[str | None]:
     """
     Return names for each input from the function or event ABI.
 
@@ -630,7 +655,7 @@ def get_abi_input_names(abi_element: ABIElement) -> List[Optional[str]]:
     ]
 
 
-def get_abi_input_types(abi_element: ABIElement) -> List[str]:
+def get_abi_input_types(abi_element: ABIElement) -> list[str]:
     """
     Return types for each input from the function or event ABI.
 
@@ -666,7 +691,7 @@ def get_abi_input_types(abi_element: ABIElement) -> List[str]:
     ]
 
 
-def get_abi_output_names(abi_element: ABIElement) -> List[Optional[str]]:
+def get_abi_output_names(abi_element: ABIElement) -> list[str | None]:
     """
     Return names for each output from the ABI element.
 
@@ -711,7 +736,7 @@ def get_abi_output_names(abi_element: ABIElement) -> List[Optional[str]]:
     ]
 
 
-def get_abi_output_types(abi_element: ABIElement) -> List[str]:
+def get_abi_output_types(abi_element: ABIElement) -> list[str]:
     """
     Return types for each output from the function ABI.
 

faster_eth_utils/address.py

@@ -2,7 +2,7 @@ import re
 from typing import (
     Any,
     Final,
-    Union,
+    TypeGuard,
 )
 
 import cchecksum
@@ -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 (
@@ -76,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.
     """
@@ -100,7 +92,7 @@ def is_normalized_address(value: Any) -> TypeGuard[HexAddress]:
     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).
     """
@@ -115,15 +107,16 @@ def is_canonical_address(address: Any) -> TypeGuard[Address]:
 8
 
 def is_same_address(
-    left: Union[AnyAddress, str, bytes], right: Union[AnyAddress, str, bytes]
+    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)
+    if left == right:
+        return True
+    return to_normalized_address(left) == to_normalized_address(right)
 
 
 def is_checksum_address(value: Any) -> TypeGuard[ChecksumAddress]:

faster_eth_utils/applicators.py

@@ -1,23 +1,18 @@
+from collections.abc import Callable, Generator, Mapping, Sequence
 from typing import (
+    TYPE_CHECKING,
     Any,
-    Callable,
-    Dict,
-    Generator,
-    List,
-    Sequence,
-    Tuple,
+    TypeGuard,
     TypeVar,
-    Union,
     cast,
+    overload,
 )
+
 import warnings
 
 from .decorators import (
     return_arg_type,
 )
-from .functional import (
-    to_dict,
-)
 from .pydantic import (
     CamelModel,
 )
@@ -26,17 +21,23 @@ from .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")
 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[[TArg], TReturn], at_index: int, value: Sequence[Union[TArg, TOther]]
-) -> Generator[Union[TOther, TReturn], None, None]:
+    formatter: Callable[[TArg], TReturn],
+    at_index: int,
+    value: Sequence[TArg | TOther],
+) -> Generator[TOther | TReturn, None, None]:
     try:
         item = value[at_index]
     except IndexError:
@@ -45,9 +46,9 @@ def apply_formatter_at_index(
             f"Need: {at_index + 1}"
         ) from None
 
-    yield from value[:at_index]
+    yield from cast(Sequence[TOther], value[:at_index])
     yield formatter(cast(TArg, item))
-    yield from value[at_index + 1 :]
+    yield from cast(Sequence[TOther], value[at_index + 1 :])
 
 
 def combine_argument_formatters(*formatters: Callable[..., Any]) -> Formatters:
@@ -63,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)
@@ -73,38 +74,55 @@ def combine_argument_formatters(*formatters: Callable[..., Any]) -> Formatters:
 
 @return_arg_type(1)
 def apply_formatters_to_sequence(
-    formatters: List[Callable[[Any], TReturn]], sequence: Sequence[Any]
+    formatters: list[Callable[[Any], TReturn]], sequence: Sequence[Any]
 ) -> Generator[TReturn, None, None]:
-    if len(formatters) == len(sequence):
+    num_formatters = len(formatters)
+    num_items = len(sequence)
+    if num_formatters == num_items:
         for formatter, item in zip(formatters, sequence):
             yield formatter(item)
-    elif len(formatters) > len(sequence):
+    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}"
         )
     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}"
         )
 
 
+@overload
+def apply_formatter_if(
+    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
-) -> Union[TArg, TReturn]:
+) -> 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: Union[Dict[Any, Any], CamelModel],
+    formatters: dict[Any, Any],
+    value: dict[Any, Any] | CamelModel,
     unaliased: bool = False,
-) -> Generator[Tuple[Any, Any], None, None]:
+) -> 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
@@ -119,22 +137,21 @@ def apply_formatters_to_dict(
     if isinstance(value, CamelModel):
         value = value.model_dump(by_alias=not unaliased)
 
-    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
+    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)
@@ -146,9 +163,11 @@ def apply_formatter_to_array(
 
 
 def apply_one_of_formatters(
-    formatter_condition_pairs: Tuple[Tuple[Callable[[TArg], Any], Callable[[TArg], 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)
@@ -158,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())
@@ -172,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()}