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

faster_eth_utils/abi.py

@@ -1,21 +1,17 @@
-from collections import (
-    abc,
-)
 import copy
 import itertools
 import re
+from collections.abc import (
+    Iterable,
+    Mapping,
+    Sequence,
+)
 from typing import (
     Any,
-    Dict,
     Final,
-    Iterable,
-    List,
+    Generic,
     Literal,
-    Mapping,
-    Optional,
-    Sequence,
-    Tuple,
-    Union,
+    TypeVar,
     cast,
     overload,
 )
@@ -31,6 +27,9 @@ from eth_typing import (
     ABIFunction,
     ABIReceive,
 )
+from typing_extensions import (
+    Self,
+)
 
 from faster_eth_utils.types import (
     is_list_like,
@@ -41,12 +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.
@@ -70,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))
+
+    elif type(aligned_arg) is list:
+        return list(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 is_list_like(aligned_arg):
+        return type(aligned_arg)(map(_align_abi_input, sub_abis, aligned_arg))  # type: ignore [call-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)
+    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])
 
@@ -123,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.
 
@@ -296,7 +321,7 @@ __ABI_TYPE_LITERALS: Final  = {
 def filter_abi_by_type(
     abi_type: Literal["function"],
     contract_abi: ABI,
-) -> List[ABIFunction]:
+) -> list[ABIFunction]:
     pass
 
 
@@ -304,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
 
 
@@ -312,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
 
 
@@ -320,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
 
 
@@ -328,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
 
 
@@ -336,16 +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: 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``.
 
@@ -375,7 +400,7 @@ ABIEvent, ABIError]]`
     """
     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: Optional[ABIType] = __ABI_TYPE_LITERALS.get(abi_type)  # type: ignore [call-overload]
+    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]    
@@ -432,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.
@@ -500,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
@@ -525,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``.
@@ -583,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
@@ -598,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.
 
@@ -634,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.
 
@@ -670,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.
 
@@ -715,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,24 +1,14 @@
-import sys
+from collections.abc import Callable, Generator, Mapping, Sequence
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
-    Dict,
-    Generator,
-    List,
-    Mapping,
-    Sequence,
-    Tuple,
+    TypeGuard,
     TypeVar,
-    Union,
     cast,
     overload,
 )
-import warnings
 
-from typing_extensions import (
-    TypeGuard,
-)
+import warnings
 
 from .decorators import (
     return_arg_type,
@@ -32,25 +22,22 @@ from .toolz import (
 )
 
 if TYPE_CHECKING:
-    if sys.version_info >= (3, 9):
-        from _typeshed import SupportsBool
+    from _typeshed import SupportsBool
     # We have to sacrifice a little bit of specificity on dinosaur Python3.8
-    else:
-        SupportsBool = Any
 
 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]:
+    value: Sequence[TArg | TOther],
+) -> Generator[TOther | TReturn, None, None]:
     try:
         item = value[at_index]
     except IndexError:
@@ -87,7 +74,7 @@ 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]:
     num_formatters = len(formatters)
     num_items = len(sequence)
@@ -111,20 +98,20 @@ def apply_formatter_if(
     condition: Callable[[TArg], TypeGuard[TOther]],
     formatter: Callable[[TOther], TReturn],
     value: TArg,
-) -> Union[TArg, TReturn]: ...
+) -> 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: Union[Callable[[TArg], TypeGuard[TOther]], Callable[[TArg], bool]],
-    formatter: Union[Callable[[TOther], TReturn], Callable[[TArg], TReturn]],
+    condition: Callable[[TArg], TypeGuard[TOther]] | Callable[[TArg], bool],
+    formatter: Callable[[TOther], TReturn] | Callable[[TArg], TReturn],
     value: TArg,
-) -> Union[TArg, TReturn]:
+) -> TArg | TReturn:
     if condition(value):
         return formatter(value)  # type: ignore [arg-type]
     else:
@@ -132,10 +119,10 @@ def apply_formatter_if(  # type: ignore [misc]
 
 
 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,
-) -> Dict[Any, Any]:
+) -> 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
@@ -176,8 +163,8 @@ def apply_formatter_to_array(
 
 
 def apply_one_of_formatters(
-    formatter_condition_pairs: Tuple[
-        Tuple[Callable[[TArg], "SupportsBool"], Callable[[TArg], TReturn]], ...
+    formatter_condition_pairs: tuple[
+        tuple[Callable[[TArg], "SupportsBool"], Callable[[TArg], TReturn]], ...
     ],
     value: TArg,
 ) -> TReturn:
@@ -191,8 +178,8 @@ def apply_one_of_formatters(
 
 
 def apply_key_map(
-    key_mappings: Dict[Any, Any], value: Mapping[Any, Any]
-) -> Dict[Any, Any]:
+    key_mappings: dict[Any, Any], value: Mapping[Any, Any]
+) -> dict[Any, Any]:
     key_conflicts = (
         set(value.keys())
         .difference(key_mappings.keys())

faster_eth_utils/conversions.py

@@ -1,9 +1,8 @@
 from typing import (
-    Callable,
-    Optional,
     TypeVar,
     Union,
 )
+from collections.abc import Callable
 
 from eth_typing import (
     HexStr,
@@ -31,9 +30,9 @@ BytesLike = Union[Primitives, bytearray, memoryview]
 
 
 def to_hex(
-    primitive: Optional[BytesLike] = None,
-    hexstr: Optional[HexStr] = None,
-    text: Optional[str] = None,
+    primitive: BytesLike | None = None,
+    hexstr: HexStr | None = None,
+    text: str | None = None,
 ) -> HexStr:
     """
     Auto converts any supported value into its hex representation.
@@ -71,9 +70,9 @@ def to_hex(
 
 
 def to_int(
-    primitive: Optional[BytesLike] = None,
-    hexstr: Optional[HexStr] = None,
-    text: Optional[str] = None,
+    primitive: BytesLike | None = None,
+    hexstr: HexStr | None = None,
+    text: str | None = None,
 ) -> int:
     """
     Converts value to its integer representation.
@@ -107,9 +106,9 @@ def to_int(
 
 
 def to_bytes(
-    primitive: Optional[BytesLike] = None,
-    hexstr: Optional[HexStr] = None,
-    text: Optional[str] = None,
+    primitive: BytesLike | None = None,
+    hexstr: HexStr | None = None,
+    text: str | None = None,
 ) -> bytes:
     if isinstance(primitive, bool):
         return b"\x01" if primitive else b"\x00"
@@ -118,10 +117,10 @@ def to_bytes(
     elif isinstance(primitive, bytes):
         return primitive
     elif isinstance(primitive, int):
-        return to_bytes(hexstr=to_hex(primitive))
+        return int_to_big_endian(primitive)
     elif hexstr is not None:
         if len(hexstr) % 2:
-            hexstr = "0x0" + remove_0x_prefix(hexstr)  # type: ignore [assignment]
+            hexstr = HexStr(f"0x0{remove_0x_prefix(hexstr)}")
         return decode_hex(hexstr)
     elif text is not None:
         return text.encode("utf-8")
@@ -132,9 +131,9 @@ def to_bytes(
 
 
 def to_text(
-    primitive: Optional[BytesLike] = None,
-    hexstr: Optional[HexStr] = None,
-    text: Optional[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")
@@ -147,13 +146,12 @@ def to_text(
     elif isinstance(primitive, memoryview):
         return bytes(primitive).decode("utf-8")
     elif isinstance(primitive, int):
-        byte_encoding = int_to_big_endian(primitive)
-        return to_text(byte_encoding)
+        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).
@@ -169,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).

faster_eth_utils/crypto.py

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