faster-eth-abi 5.2.13__cp314-cp314-macosx_11_0_arm64.whl → 5.2.15__cp314-cp314-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/_grammar.py

@@ -2,6 +2,8 @@ import re
 from typing import (
     Any,
     Final,
+    Generic,
+    Literal,
     NewType,
     NoReturn,
     Optional,
@@ -29,7 +31,6 @@ from faster_eth_abi.exceptions import (
     ABITypeError,
 )
 
-
 TYPE_ALIASES: Final = {
     "int": "int256",
     "uint": "uint256",
@@ -47,6 +48,7 @@ TYPE_ALIAS_RE: Final = re.compile(
 IntSubtype = NewType("IntSubtype", int)
 FixedSubtype = NewType("FixedSubtype", Tuple[int, int])
 Subtype = Union[IntSubtype, FixedSubtype]
+TSub = TypeVar("TSub", IntSubtype, FixedSubtype, Literal[None])
 
 
 @mypyc_attr(allow_interpreted_subclasses=True)
@@ -202,7 +204,7 @@ class TupleType(ABIType):
 
 
 @mypyc_attr(allow_interpreted_subclasses=True)
-class BasicType(ABIType):
+class BasicType(ABIType, Generic[TSub]):
     """
     Represents the result of parsing a basic type string e.g. "uint", "address",
     "ufixed128x19[][2]".
@@ -213,7 +215,7 @@ class BasicType(ABIType):
     def __init__(
         self,
         base: str,
-        sub: Optional[Subtype] = None,
+        sub: Optional[TSub] = None,
         arrlist: Optional[Sequence] = None,
         *,
         node: Optional[Node] = None,
@@ -334,6 +336,10 @@ class BasicType(ABIType):
                 self.invalidate("address cannot have suffix")
 
 
+BytesType = BasicType[IntSubtype]
+FixedType = BasicType[FixedSubtype]
+
+
 def normalize(type_str: TypeStr) -> TypeStr:
     """
     Normalizes a type string into its canonical version e.g. the type string