faster-eth-abi 5.2.13__cp39-cp39-macosx_11_0_arm64.whl → 5.2.14__cp39-cp39-macosx_11_0_arm64.whl

benchmarks/test_registry_benchmarks.py

@@ -18,25 +18,28 @@ from faster_eth_abi.registry import (
 )
 
 
+ITERATIONS = 50_000
+
+
 @pytest.mark.benchmark(group="RegistryGetEncoder")
 @pytest.mark.parametrize("type_str", type_strings)
 def test_get_encoder(benchmark: BenchmarkFixture, type_str):
-    benchmark(batch, 1000, registry.get_encoder, type_str)
+    benchmark(batch, ITERATIONS, registry.get_encoder, type_str)
 
 
 @pytest.mark.benchmark(group="RegistryGetEncoder")
 @pytest.mark.parametrize("type_str", type_strings)
 def test_faster_get_encoder(benchmark: BenchmarkFixture, type_str):
-    benchmark(batch, 1000, faster_registry.get_encoder, type_str)
+    benchmark(batch, ITERATIONS, faster_registry.get_encoder, type_str)
 
 
 @pytest.mark.benchmark(group="RegistryGetDecoder")
 @pytest.mark.parametrize("type_str", type_strings)
 def test_get_decoder(benchmark: BenchmarkFixture, type_str):
-    benchmark(batch, 1000, registry.get_decoder, type_str)
+    benchmark(batch, ITERATIONS, registry.get_decoder, type_str)
 
 
 @pytest.mark.benchmark(group="RegistryGetDecoder")
 @pytest.mark.parametrize("type_str", type_strings)
 def test_faster_get_decoder(benchmark: BenchmarkFixture, type_str):
-    benchmark(batch, 1000, faster_registry.get_decoder, type_str)
+    benchmark(batch, ITERATIONS, faster_registry.get_decoder, type_str)

faster_eth_abi/_codec.py

@@ -43,7 +43,7 @@ def encode_c(
 
     encoder = self._registry.get_tuple_encoder(*types)
 
-    return encoder(args)
+    return encoder.encode(args)
 
 
 def decode_c(

faster_eth_abi/_encoding.py

@@ -2,29 +2,59 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
+    Dict,
     List,
     Optional,
     Sequence,
+    Tuple,
     TypeVar,
 )
 
+from faster_eth_utils import (
+    is_list_like,
+)
+
+from faster_eth_abi.exceptions import (
+    ValueOutOfBounds,
+)
+
 if TYPE_CHECKING:
     from faster_eth_abi.encoding import (
         BaseEncoder,
+        TupleEncoder,
     )
 
 
 T = TypeVar("T")
 
 
-def encode_tuple(
-    values: Sequence[Any],
-    encoders: Sequence["BaseEncoder"],
-) -> bytes:
+# TupleEncoder
+def validate_tuple(self: "TupleEncoder", value: Sequence[Any]) -> None:
+    # if we check list and tuple first it compiles to much quicker C code
+    if not isinstance(value, (list, tuple)) and not is_list_like(value):
+        self.invalidate_value(
+            value,
+            msg="must be list-like object such as array or tuple",
+        )
+
+    validators = self.validators
+    if len(value) != len(validators):
+        self.invalidate_value(
+            value,
+            exc=ValueOutOfBounds,
+            msg=f"value has {len(value)} items when {len(validators)} " "were expected",
+        )
+
+    for item, validator in zip(value, validators):
+        validator(item)
+
+
+def encode_tuple(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
     raw_head_chunks: List[Optional[bytes]] = []
     tail_chunks: List[bytes] = []
-    for value, encoder in zip(values, encoders):
-        if getattr(encoder, "is_dynamic", False):
+    for value, encoder, is_dynamic in zip(values, self.encoders, self._is_dynamic):
+        if is_dynamic:
             raw_head_chunks.append(None)
             tail_chunks.append(encoder(value))
         else:
@@ -46,6 +76,111 @@ def encode_tuple(
     return b"".join(head_chunks) + b"".join(tail_chunks)
 
 
+def encode_tuple_all_dynamic(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
+    encoders = self.encoders
+    tail_chunks = [encoder(value) for encoder, value in zip(encoders, values)]
+    
+    total_offset = 0
+    head_length = 32 * len(encoders)
+    head_chunks = [encode_uint_256(head_length)]
+    for item in tail_chunks[:-1]:
+        total_offset += len(item)
+        head_chunks.append(encode_uint_256(head_length + total_offset))
+
+    return b"".join(head_chunks) + b"".join(tail_chunks)
+
+
+def encode_tuple_no_dynamic(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
+    encoders = self.encoders
+    return b"".join(encoders[i](values[i]) for i in range(len(encoders)))
+
+
+def encode_tuple_no_dynamic1(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
+    encoders: Tuple["BaseEncoder"] = self.encoders
+    return encoders[0](values[0])
+
+
+def encode_tuple_no_dynamic2(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
+    encoders = self.encoders
+    # encoders: Tuple["BaseEncoder", "BaseEncoder"] = self.encoders
+    return encoders[0](values[0]) + encoders[1](values[1])
+
+
+def encode_tuple_no_dynamic3(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
+    encoders = self.encoders
+    # encoders: Tuple["BaseEncoder", "BaseEncoder", "BaseEncoder"] = self.encoders
+    return b"".join(encoders[i](values[i]) for i in range(3))
+
+
+def encode_tuple_no_dynamic4(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
+    encoders = self.encoders
+    # encoders: Tuple["BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder"] = self.encoders
+    return b"".join(encoders[i](values[i]) for i in range(4))
+
+
+def encode_tuple_no_dynamic5(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
+    encoders = self.encoders
+    # encoders: Tuple["BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder"] = self.encoders
+    return b"".join(encoders[i](values[i]) for i in range(5))
+
+
+def encode_tuple_no_dynamic6(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
+    encoders = self.encoders
+    # encoders: Tuple["BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder"] = self.encoders
+    return b"".join(encoders[i](values[i]) for i in range(6))
+
+
+def encode_tuple_no_dynamic7(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
+    encoders = self.encoders
+    # encoders: Tuple["BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder"] = self.encoders
+    return b"".join(encoders[i](values[i]) for i in range(7))
+
+
+def encode_tuple_no_dynamic8(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
+    encoders = self.encoders
+    # encoders: Tuple["BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder"] = self.encoders
+    return b"".join(encoders[i](values[i]) for i in range(8))
+
+
+def encode_tuple_no_dynamic9(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
+    encoders = self.encoders
+    # encoders: Tuple["BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder"] = self.encoders
+    return b"".join(encoders[i](values[i]) for i in range(9))
+
+
+def encode_tuple_no_dynamic10(self: "TupleEncoder", values: Sequence[Any]) -> bytes:
+    validate_tuple(self, values)
+    encoders = self.encoders
+    # encoders: Tuple["BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder", "BaseEncoder"] = self.encoders
+    return b"".join(encoders[i](values[i]) for i in range(10))
+
+encode_tuple_no_dynamic_funcs: Dict[
+    int, Callable[["TupleEncoder", Sequence[Any]], bytes]
+] = {
+    1: encode_tuple_no_dynamic1,
+    2: encode_tuple_no_dynamic2,
+    3: encode_tuple_no_dynamic3,
+    4: encode_tuple_no_dynamic4,
+    5: encode_tuple_no_dynamic5,
+    6: encode_tuple_no_dynamic6,
+    7: encode_tuple_no_dynamic7,
+    8: encode_tuple_no_dynamic8,
+    9: encode_tuple_no_dynamic9,
+    10: encode_tuple_no_dynamic10,
+}
+
+
 def encode_fixed(
     value: Any,
     encode_fn: Callable[[Any], bytes],

faster_eth_abi/decoding.py

@@ -163,10 +163,7 @@ class SingleDecoder(BaseDecoder):
     def decode(self, stream: ContextFramesBytesIO) -> Any:
         raw_data = self.read_data_from_stream(stream)
         data, padding_bytes = self.split_data_and_padding(raw_data)
-        decoder_fn = self.decoder_fn
-        if decoder_fn is None:
-            raise AssertionError("`decoder_fn` is None")
-        value = decoder_fn(data)
+        value = self.decoder_fn(data)  # type: ignore [misc]
         self.validate_padding_bytes(value, padding_bytes)
 
         return value
@@ -190,6 +187,7 @@ class BaseArrayDecoder(BaseDecoder):
         item_decoder = self.item_decoder
         if item_decoder.is_dynamic:
             self.item_decoder = HeadTailDecoder(tail_decoder=item_decoder)
+            self.validate_pointers = MethodType(validate_pointers_array, self)
         else:
 
             def noop(stream: ContextFramesBytesIO, array_size: int) -> None:
@@ -354,6 +352,13 @@ decode_uint_256 = UnsignedIntegerDecoder(value_bit_size=256)
 class SignedIntegerDecoder(Fixed32ByteSizeDecoder):
     is_big_endian = True
 
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+    
+        # Only assign validate_padding_bytes if not overridden in subclass
+        if type(self).validate_padding_bytes is SignedIntegerDecoder.validate_padding_bytes:
+            self.validate_padding_bytes = MethodType(validate_padding_bytes_signed_integer, self)
+
     @cached_property
     def neg_threshold(self) -> int:
         return int(2 ** (self.value_bit_size - 1))
@@ -394,6 +399,10 @@ class BytesDecoder(Fixed32ByteSizeDecoder):
 class BaseFixedDecoder(Fixed32ByteSizeDecoder):
     frac_places: int = None
     is_big_endian = True
+    
+    @cached_property
+    def denominator(self) -> decimal.Decimal:
+        return TEN**self.frac_places
 
     def validate(self) -> None:
         super().validate()
@@ -407,11 +416,12 @@ class BaseFixedDecoder(Fixed32ByteSizeDecoder):
 
 
 class UnsignedFixedDecoder(BaseFixedDecoder):
+    
     def decoder_fn(self, data: bytes) -> decimal.Decimal:
         value = big_endian_to_int(data)
 
         with decimal.localcontext(abi_decimal_context):
-            decimal_value = decimal.Decimal(value) / TEN**self.frac_places
+            decimal_value = decimal.Decimal(value) / self.denominator
 
         return decimal_value
 
@@ -423,27 +433,42 @@ class UnsignedFixedDecoder(BaseFixedDecoder):
 
 
 class SignedFixedDecoder(BaseFixedDecoder):
+    
+    @cached_property
+    def neg_threshold(self) -> int:
+        return int(2 ** (self.value_bit_size - 1))
+
+    @cached_property
+    def neg_offset(self) -> int:
+        return int(2**self.value_bit_size)
+
+    @cached_property
+    def expected_padding_pos(self) -> bytes:
+        value_byte_size = get_value_byte_size(self)
+        padding_size = self.data_byte_size - value_byte_size
+        return b"\x00" * padding_size
+
+    @cached_property
+    def expected_padding_neg(self) -> bytes:
+        value_byte_size = get_value_byte_size(self)
+        padding_size = self.data_byte_size - value_byte_size
+        return b"\xff" * padding_size
+
     def decoder_fn(self, data: bytes) -> decimal.Decimal:
         value = big_endian_to_int(data)
-        value_bit_size = self.value_bit_size
-        if value >= 2 ** (value_bit_size - 1):
-            signed_value = value - 2**value_bit_size
-        else:
-            signed_value = value
+        if value >= self.neg_threshold:
+            value -= self.neg_offset
 
         with decimal.localcontext(abi_decimal_context):
-            decimal_value = decimal.Decimal(signed_value) / TEN**self.frac_places
+            decimal_value = decimal.Decimal(value) / self.denominator
 
         return decimal_value
 
     def validate_padding_bytes(self, value: Any, padding_bytes: bytes) -> None:
-        value_byte_size = get_value_byte_size(self)
-        padding_size = self.data_byte_size - value_byte_size
-
         if value >= 0:
-            expected_padding_bytes = b"\x00" * padding_size
+            expected_padding_bytes = self.expected_padding_pos
         else:
-            expected_padding_bytes = b"\xff" * padding_size
+            expected_padding_bytes = self.expected_padding_neg
 
         if padding_bytes != expected_padding_bytes:
             raise NonEmptyPaddingBytes(

faster_eth_abi/encoding.py

@@ -1,15 +1,23 @@
 import abc
 import codecs
 import decimal
+from functools import (
+    cached_property,
+)
+from types import (
+    MethodType,
+)
 from typing import (
     Any,
     Callable,
     ClassVar,
+    Final,
     NoReturn,
     Optional,
     Sequence,
     Tuple,
     Type,
+    final,
 )
 
 from faster_eth_utils import (
@@ -32,7 +40,11 @@ from faster_eth_abi._encoding import (
     encode_fixed,
     encode_signed,
     encode_tuple,
+    encode_tuple_all_dynamic,
+    encode_tuple_no_dynamic,
+    encode_tuple_no_dynamic_funcs,
     int_to_big_endian,
+    validate_tuple,
 )
 from faster_eth_abi.base import (
     BaseCoder,
@@ -111,7 +123,33 @@ class TupleEncoder(BaseEncoder):
     def __init__(self, encoders: Tuple[BaseEncoder, ...], **kwargs: Any) -> None:
         super().__init__(encoders=encoders, **kwargs)
 
-        self.is_dynamic = any(getattr(e, "is_dynamic", False) for e in self.encoders)
+        self._is_dynamic: Final = tuple(getattr(e, "is_dynamic", False) for e in self.encoders)
+        self.is_dynamic = any(self._is_dynamic)
+
+        validators = []
+        for encoder in self.encoders:
+            try:
+                validator = encoder.validate_value
+            except AttributeError:
+                validators.append(encoder)
+            else:
+                validators.append(validator)
+        
+        self.validators: Final[Callable[[Any], None]] = tuple(validators)
+
+        if type(self).encode is TupleEncoder.encode:
+            encode_func = (
+                encode_tuple_all_dynamic
+                if all(self._is_dynamic)
+                else encode_tuple_no_dynamic_funcs.get(
+                    len(self.encoders),
+                    encode_tuple_no_dynamic,
+                )
+                if not self.is_dynamic
+                else encode_tuple
+            )
+                
+            self.encode = MethodType(encode_func, self)
 
     def validate(self) -> None:
         super().validate()
@@ -119,33 +157,15 @@ class TupleEncoder(BaseEncoder):
         if self.encoders is None:
             raise ValueError("`encoders` may not be none")
 
+    @final
     def validate_value(self, value: Sequence[Any]) -> None:
-        if not is_list_like(value):
-            self.invalidate_value(
-                value,
-                msg="must be list-like object such as array or tuple",
-            )
-
-        encoders = self.encoders
-        if len(value) != len(encoders):
-            self.invalidate_value(
-                value,
-                exc=ValueOutOfBounds,
-                msg=f"value has {len(value)} items when {len(encoders)} "
-                "were expected",
-            )
-
-        for item, encoder in zip(value, encoders):
-            try:
-                encoder.validate_value(item)
-            except AttributeError:
-                encoder(item)
+        validate_tuple(self, value)
 
     def encode(self, values: Sequence[Any]) -> bytes:
-        self.validate_value(values)
-        return encode_tuple(values, self.encoders)
+        return encode_tuple(self, values)
 
-    __call__: Callable[[Self, Sequence[Any]], bytes] = encode
+    def __call__(self, values: Sequence[Any]) -> bytes:
+        return self.encode(values)
 
     @parse_tuple_type_str
     def from_type_str(cls, abi_type, registry):
@@ -328,11 +348,19 @@ class BaseFixedEncoder(NumberEncoder):
 
         return False
 
+    @cached_property
+    def denominator(self) -> decimal.Decimal:
+        return TEN**self.frac_places
+
+    @cached_property
+    def precision(self) -> int:
+        return TEN**-self.frac_places
+
     def validate_value(self, value):
         super().validate_value(value)
 
         with decimal.localcontext(abi_decimal_context):
-            residue = value % (TEN**-self.frac_places)
+            residue = value % self.precision
 
         if residue > 0:
             self.invalidate_value(
@@ -359,7 +387,7 @@ class UnsignedFixedEncoder(BaseFixedEncoder):
 
     def encode_fn(self, value):
         with decimal.localcontext(abi_decimal_context):
-            scaled_value = value * TEN**self.frac_places
+            scaled_value = value * self.denominator
             integer_value = int(scaled_value)
 
         return int_to_big_endian(integer_value)
@@ -392,7 +420,7 @@ class SignedFixedEncoder(BaseFixedEncoder):
 
     def encode_fn(self, value):
         with decimal.localcontext(abi_decimal_context):
-            scaled_value = value * TEN**self.frac_places
+            scaled_value = value * self.denominator
             integer_value = int(scaled_value)
 
         unsigned_integer_value = integer_value % (2**self.value_bit_size)

faster_eth_abi/registry.py

@@ -1,12 +1,15 @@
 import abc
+from copy import (
+    copy,
+)
 import functools
-from copy import copy
 from typing import (
     Any,
     Callable,
     Dict,
     Final,
     Generic,
+    Iterator,
     Optional,
     Type,
     TypeVar,
@@ -17,6 +20,8 @@ from eth_typing import (
     TypeStr,
 )
 from typing_extensions import (
+    Concatenate,
+    ParamSpec,
     Self,
 )
 
@@ -38,6 +43,7 @@ from .io import (
 )
 
 T = TypeVar("T")
+P = ParamSpec("P")
 
 Lookup = Union[TypeStr, Callable[[TypeStr], bool]]
 
@@ -177,25 +183,25 @@ class Predicate:
     ``ABIRegistry``.
     """
 
-    __slots__ = tuple()
+    __slots__ = ()
 
     def __call__(self, *args, **kwargs):  # pragma: no cover
         raise NotImplementedError("Must implement `__call__`")
 
-    def __str__(self):  # pragma: no cover
+    def __str__(self) -> str:
         raise NotImplementedError("Must implement `__str__`")
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"<{type(self).__name__} {self}>"
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[Any]:
         for attr in self.__slots__:
             yield getattr(self, attr)
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         return hash(tuple(self))
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> bool:
         return type(self) is type(other) and tuple(self) == tuple(other)
 
 
@@ -209,10 +215,10 @@ class Equals(Predicate):
     def __init__(self, value):
         self.value = value
 
-    def __call__(self, other):
+    def __call__(self, other: Any) -> bool:
         return self.value == other
 
-    def __str__(self):
+    def __str__(self) -> str:
         return f"(== {self.value!r})"
 
 
@@ -231,7 +237,7 @@ class BaseEquals(Predicate):
         self.base = base
         self.with_sub = with_sub
 
-    def __call__(self, type_str):
+    def __call__(self, type_str: TypeStr) -> bool:
         try:
             abi_type = grammar.parse(type_str)
         except (exceptions.ParseError, ValueError):
@@ -253,7 +259,7 @@ class BaseEquals(Predicate):
         # e.g. if it contained a tuple type
         return False
 
-    def __str__(self):
+    def __str__(self) -> str:
         return (
             f"(base == {self.base!r}"
             + (
@@ -265,7 +271,7 @@ class BaseEquals(Predicate):
         )
 
 
-def has_arrlist(type_str):
+def has_arrlist(type_str: TypeStr) -> bool:
     """
     A predicate that matches a type string with an array dimension list.
     """
@@ -277,7 +283,7 @@ def has_arrlist(type_str):
     return abi_type.arrlist is not None
 
 
-def is_base_tuple(type_str):
+def is_base_tuple(type_str: TypeStr) -> bool:
     """
     A predicate that matches a tuple type with no array dimension list.
     """
@@ -289,9 +295,11 @@ def is_base_tuple(type_str):
     return isinstance(abi_type, grammar.TupleType) and abi_type.arrlist is None
 
 
-def _clear_encoder_cache(old_method: Callable[..., None]) -> Callable[..., None]:
+def _clear_encoder_cache(
+    old_method: Callable[Concatenate["ABIRegistry", P], T]
+) -> Callable[Concatenate["ABIRegistry", P], T]:
     @functools.wraps(old_method)
-    def new_method(self: "ABIRegistry", *args: Any, **kwargs: Any) -> None:
+    def new_method(self: "ABIRegistry", *args: P.args, **kwargs: P.kwargs) -> T:
         self.get_encoder.cache_clear()
         self.get_tuple_encoder.cache_clear()
         return old_method(self, *args, **kwargs)
@@ -299,9 +307,11 @@ def _clear_encoder_cache(old_method: Callable[..., None]) -> Callable[..., None]
     return new_method
 
 
-def _clear_decoder_cache(old_method: Callable[..., None]) -> Callable[..., None]:
+def _clear_decoder_cache(
+    old_method: Callable[Concatenate["ABIRegistry", P], T]
+) -> Callable[Concatenate["ABIRegistry", P], T]:
     @functools.wraps(old_method)
-    def new_method(self: "ABIRegistry", *args: Any, **kwargs: Any) -> None:
+    def new_method(self: "ABIRegistry", *args: P.args, **kwargs: P.kwargs) -> T:
         self.get_decoder.cache_clear()
         self.get_tuple_decoder.cache_clear()
         return old_method(self, *args, **kwargs)
@@ -311,7 +321,12 @@ def _clear_decoder_cache(old_method: Callable[..., None]) -> Callable[..., None]
 
 class BaseRegistry:
     @staticmethod
-    def _register(mapping, lookup, value, label=None):
+    def _register(
+        mapping: PredicateMapping[T],
+        lookup: Lookup,
+        value: T,
+        label: Optional[str] = None,
+    ) -> None:
         if callable(lookup):
             mapping.add(lookup, value, label)
             return
@@ -325,7 +340,7 @@ class BaseRegistry:
         )
 
     @staticmethod
-    def _unregister(mapping, lookup_or_label):
+    def _unregister(mapping: PredicateMapping[Any], lookup_or_label: Lookup) -> None:
         if callable(lookup_or_label):
             mapping.remove_by_equality(lookup_or_label)
             return
@@ -340,7 +355,7 @@ class BaseRegistry:
         )
 
     @staticmethod
-    def _get_registration(mapping, type_str):
+    def _get_registration(mapping: PredicateMapping[T], type_str: TypeStr) -> T:
         try:
             value = mapping.find(type_str)
         except ValueError as e:
@@ -473,16 +488,15 @@ class ABIRegistry(Copyable, BaseRegistry):
         self.unregister_encoder(label)
         self.unregister_decoder(label)
 
-    def _get_encoder_uncached(self, type_str: TypeStr):  # type: ignore [no-untyped-def]
+    def _get_encoder_uncached(self, type_str: TypeStr) -> Encoder:
         return self._get_registration(self._encoders, type_str)
 
     def _get_tuple_encoder_uncached(
-        self, 
+        self,
         *type_strs: TypeStr,
     ) -> encoding.TupleEncoder:
-        return encoding.TupleEncoder(
-            encoders=tuple(self.get_encoder(type_str) for type_str in type_strs)
-        )
+        encoders = tuple(map(self.get_encoder, type_strs))
+        return encoding.TupleEncoder(encoders=encoders)
 
     def has_encoder(self, type_str: TypeStr) -> bool:
         """
@@ -500,7 +514,7 @@ class ABIRegistry(Copyable, BaseRegistry):
 
         return True
 
-    def _get_decoder_uncached(self, type_str: TypeStr, strict: bool = True):  # type: ignore [no-untyped-def]
+    def _get_decoder_uncached(self, type_str: TypeStr, strict: bool = True) -> Decoder:
         decoder = self._get_registration(self._decoders, type_str)
 
         if hasattr(decoder, "is_dynamic") and decoder.is_dynamic:
@@ -512,15 +526,17 @@ class ABIRegistry(Copyable, BaseRegistry):
         return decoder
 
     def _get_tuple_decoder_uncached(
-        self, 
-        *type_strs: TypeStr, 
+        self,
+        *type_strs: TypeStr,
         strict: bool = True,
     ) -> decoding.TupleDecoder:
-        return decoding.TupleDecoder(
-            decoders=tuple(self.get_decoder(type_str, strict) for type_str in type_strs)
+        decoders = tuple(
+            self.get_decoder(type_str, strict)  # type: ignore [misc]
+            for type_str in type_strs
         )
+        return decoding.TupleDecoder(decoders=decoders)
 
-    def copy(self):
+    def copy(self) -> Self:
         """
         Copies a registry such that new registrations can be made or existing
         registrations can be unregistered without affecting any instance from

{faster_eth_abi-5.2.13.dist-info → faster_eth_abi-5.2.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: faster_eth_abi
-Version: 5.2.13
+Version: 5.2.14
 Summary: A faster fork of eth_abi: Python utilities for working with Ethereum ABI definitions, especially encoding and decoding. Implemented in C.
 Home-page: https://github.com/BobTheBuidler/faster-eth-abi
 Author: The Ethereum Foundation

{faster_eth_abi-5.2.13.dist-info → faster_eth_abi-5.2.14.dist-info}/RECORD

@@ -1,45 +1,50 @@
-faster_eth_abi__mypyc.cpython-39-darwin.so,sha256=huSn2poUCKwNvXlGWy9_NU_XRQapup6p6Xmg6kfKQO0,631912
-faster_eth_abi/_encoding.py,sha256=nBIqwHbvT7loTmiYlcl7Z8HhnOGEY-jr-cpCZEU-1X8,3230
+faster_eth_abi__mypyc.cpython-39-darwin.so,sha256=KT3djdqKL3NjeRzGQ6vCBLrqUWLbWAlhUdgJUEARcWo,695112
+faster_eth_abi/_encoding.py,sha256=n3POAR1IAjQObaDTY_GyqgQPwmTIC2CT7VuAf5vBvyg,8540
 faster_eth_abi/packed.py,sha256=qDPBjish_0h26O7xGWopnlD4pRkphFuFq4izgIqT600,301
-faster_eth_abi/encoding.py,sha256=lH6t_8rokfmg8M4JBjmIO3a3l9jGu_rbwoskb0PcH7M,19009
-faster_eth_abi/registry.py,sha256=RqHQNDLzvQ6embdnOSxlpvPw7dn-jqUU9MshLe5JuuM,21082
+faster_eth_abi/encoding.py,sha256=3-MNnZ7PUNZXUbu-HrmM_PDSVfAEZcdmrbMu8GHqYMQ,19685
+faster_eth_abi/registry.py,sha256=HmspZBvwUrkeVjecCOQJUjXkYP5aDAGbkCx1CzASppk,21554
 faster_eth_abi/_decoding.py,sha256=WbFy1GxPYGHduUNCjiTz4gLbNuDffbbJ6MFujjINTpw,9613
-faster_eth_abi/_codec.cpython-39-darwin.so,sha256=n6UP7b7L-r4o2rHJUH_O6pUzQlJvYxGSa7ADxicd0Yo,50632
+faster_eth_abi/_codec.cpython-39-darwin.so,sha256=8eRdMo_ZID0pRdeURhGN0WQuzIntPk0dzO79zzHXo9c,50632
 faster_eth_abi/constants.py,sha256=uJbuND1rFs_Pexuz58TKd-BJPuoA6hLqFEX6kkDS-dE,107
 faster_eth_abi/io.py,sha256=PjOnBChWh_-6ADkpJQONnxHVwsAfC_4bRiT6YQhlP6c,3728
 faster_eth_abi/__init__.py,sha256=55jGpiVbsTGNu-c_rr-wwyH3eqEv9MELSTWa4AMiKvU,205
 faster_eth_abi/_grammar.py,sha256=6REsztEP6kJvWSB3DoLRGbl1whc-pLj5aEWrT6GxaN0,10142
-faster_eth_abi/packed.cpython-39-darwin.so,sha256=awzvwPh1-gUMkxyQNxfpV0KRtJ7VEQstFKWab_ZeXW4,50632
-faster_eth_abi/abi.cpython-39-darwin.so,sha256=UifpiNfv7uBdba-5lcnEqfrT8Ui54NzUqKfENo5wZDs,50632
-faster_eth_abi/from_type_str.cpython-39-darwin.so,sha256=00S5OAB9wOTIJEE97odFF4XCqan5ukT4t8LllE8ev-M,50672
-faster_eth_abi/decoding.py,sha256=MYddNAyi3cUKnkV0KYSvff8SeJe3oXaw0GH--iujLzY,15350
+faster_eth_abi/packed.cpython-39-darwin.so,sha256=tEBrqs9ApOVDDHGFGRKwawrugpdO-2ZQ-85WuZa-0QY,50632
+faster_eth_abi/abi.cpython-39-darwin.so,sha256=mOh5DejFuGgItVILGDW9aniDqaNCo0a0mqkFfCZHDEg,50632
+faster_eth_abi/from_type_str.cpython-39-darwin.so,sha256=HmUhCENW1owjS8fT6QFVM7IF_NzqjXKHWcuHsFo9NwQ,50672
+faster_eth_abi/decoding.py,sha256=vBrGAol7NC_7iA3j4V_rwtLwo2hzK1b60-o559iuHls,16227
 faster_eth_abi/grammar.py,sha256=JJ7QLGJVKmoWwx3J8O-5snrza-Si4NdCweUummqzjlo,4511
-faster_eth_abi/_encoding.cpython-39-darwin.so,sha256=1yj5Paf90_G2srbVrhXt0QfeV5QKjmNyEGAHCxxCJAk,50656
+faster_eth_abi/_encoding.cpython-39-darwin.so,sha256=rKbIpCR3AQrmSMehIHwWL3LhpwvsmbLn6f_oDlzcp7s,50656
 faster_eth_abi/from_type_str.py,sha256=C3QNACXS-5lTtOx1kNAqfZLvky37wV7gqY3Cf9QoEkk,4337
-faster_eth_abi/_grammar.cpython-39-darwin.so,sha256=F5q3iL_0AiLwu_Awz500meyowy-3RkG5o1rhfSYC7Ps,50656
-faster_eth_abi/constants.cpython-39-darwin.so,sha256=uUPbIbif0ciYwLRn0jlhV1aQ9VaUbSdxKlRo4yX0du8,50656
+faster_eth_abi/_grammar.cpython-39-darwin.so,sha256=SIPhwYnBJlF8oCd-F8UO0O9h6SegSCDvi-hi0ILrGb0,50656
+faster_eth_abi/constants.cpython-39-darwin.so,sha256=lKGj90TMS7t0bvNBvIkFopD4vjiRq_Y1JB-ENP9xLe4,50656
 faster_eth_abi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 faster_eth_abi/abi.py,sha256=HzkXy0EjHraNbbC5l-EhVqVcx5vy8tcykiKIO4Fp1xw,366
 faster_eth_abi/exceptions.py,sha256=pbwvH_WeAlSlwqA8w79e_RCt8_uaasLcGtRY7yT9LTQ,3577
-faster_eth_abi/_codec.py,sha256=7TfO2ij2jBuUK54LuMdhC0YX8NEui3rnN2ZG1NnP3dA,2264
+faster_eth_abi/_codec.py,sha256=qcK1Mfy_6tO48srobl-WyBBIkEFzwpMQrdGQ8H5TH-o,2271
 faster_eth_abi/codec.py,sha256=2CtGd3SdNCF5mLqTrZ2FpMAyBtFt83IGu81T--Gevyc,4415
 faster_eth_abi/base.py,sha256=eMpUM78FhJg5wHPj6glvJRpS1AmvQ_1ks9ENwyu68hc,1188
-faster_eth_abi/_decoding.cpython-39-darwin.so,sha256=BaIl-55QMZXW4iZfk6AZ-F7yPpQ9VlXnicy68VugdhM,50656
+faster_eth_abi/_decoding.cpython-39-darwin.so,sha256=rm-FvOJjertsekewwmTW14XDt315mQCnZt5EpeN9IZA,50656
 faster_eth_abi/tools/_strategies.py,sha256=XQhK8eG87W7LB5v6ibzEAB0BkhTr-oc7dIzPvZu6AE0,6089
 faster_eth_abi/tools/__init__.py,sha256=trtATEmgu4ctg04qkejbODDzvDSofgcVJ3rkzMP_hQE,51
-faster_eth_abi/tools/__init__.cpython-39-darwin.so,sha256=-hdvztdSxmImzuCqb9GFGJmlNypl4Iu3NmqdoBeDfrM,50640
-faster_eth_abi/tools/_strategies.cpython-39-darwin.so,sha256=QoxWn3vAQC_sO2agLJ7npCuMqPI4rB9N7hIX_PA9zpc,50672
+faster_eth_abi/tools/__init__.cpython-39-darwin.so,sha256=ToJaEIptQwzDFE_BnbVIHlKz4omS66Xa5heYIxjib7g,50640
+faster_eth_abi/tools/_strategies.cpython-39-darwin.so,sha256=-NwvUYXHBxsor0sklAvyeoC6-Eok-9dAi6itP4ruIfc,50672
 faster_eth_abi/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-faster_eth_abi/utils/validation.cpython-39-darwin.so,sha256=CM6WNz5aHKoIHKKMK0uoOSMvg9PWJNluyZ-r8n5ofrw,50672
-faster_eth_abi/utils/__init__.cpython-39-darwin.so,sha256=jm_0szKPmWh3dB1H-WtdT_rUmxwa1ZTL2Gd2MeB0Vts,50640
-faster_eth_abi/utils/string.cpython-39-darwin.so,sha256=tUsM_c9VMqAut2vctoZuiXOgxGSbCJj3Qw1FlfNP5Yo,50648
-faster_eth_abi/utils/numeric.cpython-39-darwin.so,sha256=zV1-9ViLK3mZ8QFULItxn1hyHgrLt4BRzjH04eGdt5U,50656
+faster_eth_abi/utils/validation.cpython-39-darwin.so,sha256=XBgELw1ZWFb4uQi6GxEOnHOzjLdpItqyryY_xajhY2g,50672
+faster_eth_abi/utils/__init__.cpython-39-darwin.so,sha256=1LPf4NdcGOrgU2cqJYejOeanhejnkqI2T66-75kBXQU,50640
+faster_eth_abi/utils/string.cpython-39-darwin.so,sha256=epvySWV16R1QdMZiEPowGrLYH8hDBWYhKeTLjL2a760,50648
+faster_eth_abi/utils/numeric.cpython-39-darwin.so,sha256=K92jVUL9PZvTaWojLRXrpMqwqM9mOQ2RAtHm7BsR6_4,50656
 faster_eth_abi/utils/numeric.py,sha256=fkdazLcgd7FN0JGSSyb6Jsx555QdgRf2N0mxrm6rGB4,3278
 faster_eth_abi/utils/string.py,sha256=fjsAR2C7Xlu5bHomxx5l4rlADFtByzGTQfugMTo8TQk,436
-faster_eth_abi/utils/padding.cpython-39-darwin.so,sha256=-Tk67l5wbblUsidEEqj9KQIQ2M26AAugQ27oPmolkFI,50656
+faster_eth_abi/utils/padding.cpython-39-darwin.so,sha256=QO_41oapDBTN72vc5C340TPUQFJvYFx4bCE_4iDL6vw,50656
 faster_eth_abi/utils/padding.py,sha256=JBuFhdrvKWLrmmJBZ-a6pqbHWydAuiUBt2aBjCwVcVE,493
 faster_eth_abi/utils/validation.py,sha256=NA2wRacYEBdkpQnZfmeDvzF-sHyy6NT2QzCFuBnYJVI,521
-benchmarks/test_registry_benchmarks.py,sha256=76bFMgx0o4YxWfMszWJdmancPtywNJBN38nehhXeMRM,1216
+faster_eth_abi-5.2.14.dist-info/RECORD,,
+faster_eth_abi-5.2.14.dist-info/WHEEL,sha256=bDWaFWigpG5bEpqw9IoRiyYs8MvmSFh0OhUAOoi_-KA,134
+faster_eth_abi-5.2.14.dist-info/top_level.txt,sha256=z3gorxabz8D2eg5A3YX2M3p3JMFRLLX3DRp0jAwNZOY,48
+faster_eth_abi-5.2.14.dist-info/METADATA,sha256=9Y3LCTA4ytM8PUoj2EoYJ1QTfGfyli9EY-HQCu2ugx8,6978
+faster_eth_abi-5.2.14.dist-info/licenses/LICENSE,sha256=P_zrhVa0OXK-_XuA0RF3d3gwMLXRSBkn2fWraC4CFLo,1106
+benchmarks/test_registry_benchmarks.py,sha256=RQTkFsOk9pIDPd84bZqm3mfBuKSYhuQCCmSblYDzFOE,1262
 benchmarks/type_strings.py,sha256=tC12IvA5TbJFQDvydi1lCxnCHUxWurBW69xLG9Xjywc,566
 benchmarks/batch.py,sha256=8MkG1hAxZerEnPTtrESUAWXB6C-iNnCMQ5yJMz3HDIM,199
 benchmarks/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
@@ -50,8 +55,3 @@ benchmarks/test_io_benchmarks.py,sha256=SkBGL0FijyVefSlL1VTQIaD1b2oruWjdo6WAck8r
 benchmarks/test_encoding_benchmarks.py,sha256=sfVncm7BGIV0k_byD8HCjuwc8oGx4-KLnx8Jk8_9uD0,3212
 benchmarks/data.py,sha256=YeU6gxSF2_XFVnwy7N2CuEiqiS8AFrc4ZQ4B3Z0HRw4,9205
 benchmarks/test_decoding_benchmarks.py,sha256=MVZ4lN1V8OTvO-957joBBOgkHnsfSghF3d_GiBeEh1E,3904
-faster_eth_abi-5.2.13.dist-info/RECORD,,
-faster_eth_abi-5.2.13.dist-info/WHEEL,sha256=bDWaFWigpG5bEpqw9IoRiyYs8MvmSFh0OhUAOoi_-KA,134
-faster_eth_abi-5.2.13.dist-info/top_level.txt,sha256=z3gorxabz8D2eg5A3YX2M3p3JMFRLLX3DRp0jAwNZOY,48
-faster_eth_abi-5.2.13.dist-info/METADATA,sha256=xmxMq_V5kqGXUFQQWEQB33b7JhiezKLg--TTfjkK60s,6978
-faster_eth_abi-5.2.13.dist-info/licenses/LICENSE,sha256=P_zrhVa0OXK-_XuA0RF3d3gwMLXRSBkn2fWraC4CFLo,1106