faster-eth-abi 5.2.15__cp314-cp314t-win32.whl → 5.2.16__cp314-cp314t-win32.whl

benchmarks/data.py

@@ -1,313 +0,0 @@
-# Shared value lists for encoding/decoding/packed/abi benchmarks
-
-from decimal import (
-    Decimal,
-)
-
-# Granular lists for encoding/decoding
-booleans = [True, False]
-
-addresses = [
-    b"\x00" * 19 + b"\x01",
-    b"\xff" * 20,
-    b"\x01" * 20,
-    b"\x00" * 20,
-    b"\x12" * 20,
-    b"\x00" * 19 + b"\x02",
-    b"\x01" * 19 + b"\x00",
-]
-
-uint256s = [
-    0,
-    1,
-    2**256 - 1,
-    2**128,
-    2**64,
-    12345678901234567890,
-    2**255,
-    2**255 - 1,
-    2**32,
-    2**16,
-    42,
-    999999999999999999999999999999,
-]
-
-bytes32s = [
-    b"\x00" * 32,
-    b"\xff" * 32,
-    b"abc" * 10 + b"de",
-    b"\x01" * 32,
-    b"\x12" * 32,
-    b"",  # empty
-    b"\x00" * 16,  # short
-]
-
-bytes32_ids = list(map(repr, bytes32s))
-
-strings = [
-    "",
-    "hello world",
-    "𝔘𝔫𝔦𝔠𝔬𝔡𝔢",
-    "a" * 256,
-    "b" * 1024,
-    "c" * 4096,
-    "d" * 8192,
-    "e" * 16384,
-    "f" * 32768,
-    "g" * 65536,
-    "\0",  # null byte
-    "a\nb",  # newline
-    "a" * 100000,  # very long
-]
-
-string_ids = [
-    "empty",
-    "hello-world",
-    "unicode",
-    "'a' * 256",
-    "'b' * 1024",
-    "'c' * 4096",
-    "'d' * 8192",
-    "'e' * 16384",
-    "'f' * 32768",
-    "'g' * 65536",
-    "null-byte",
-    "newline",
-    "very-long",
-]
-
-tuples = [
-    ((1, True), ["uint256", "bool"]),
-    ((b"\x00" * 32, "foo"), ["bytes32", "string"]),
-    ((2**255 - 1, False, "bar"), ["int256", "bool", "string"]),
-    (([1, 2, 3], [True, False]), ["uint8[3]", "bool[2]"]),
-    ((b"\x01" * 20, 0), ["address", "uint8"]),
-    (([b"\x00" * 32, b"\xff" * 32], ["a", "b"]), ["bytes32[2]", "string[2]"]),
-]
-tuple_ids = [
-    "int-bool",
-    "bytes-string",
-    "int-bool-string",
-    "arrs",
-    "addr-uint8",
-    "bytes32s-strings",
-]
-
-# --- Comprehensive ABI test cases for abi/packed benchmarks ---
-
-
-# Primitive types
-def make_fixed_decimal(bits: int, exp: int) -> Decimal:
-    # For each (bits, exp), generate a value within the allowed range
-    # Range: [-2**(bits-1)/10**exp, 2**(bits-1)-1/10**exp]
-    max_val = (2 ** (bits - 1) - 1) / (10**exp)
-    min_val = -(2 ** (bits - 1)) / (10**exp)
-    # Use a value safely within the range, e.g., 1.2 or 0.1 if possible
-    if max_val >= 1.2 and min_val <= -1.2:
-        return Decimal("1.2").quantize(Decimal("1." + "0" * exp))
-    elif max_val >= 0.1:
-        return Decimal("0.1").quantize(Decimal("1." + "0" * exp))
-    else:
-        return Decimal(str(max_val)).quantize(Decimal("1." + "0" * exp))
-
-
-def make_ufixed_decimal(bits: int, exp: int) -> Decimal:
-    # For each (bits, exp), generate a value within the allowed range
-    # Range: [0, 2**bits-1/10**exp]
-    max_val = (2**bits - 1) / (10**exp)
-    if max_val >= 1.2:
-        return Decimal("1.2").quantize(Decimal("1." + "0" * exp))
-    elif max_val >= 0.1:
-        return Decimal("0.1").quantize(Decimal("1." + "0" * exp))
-    else:
-        return Decimal(str(max_val)).quantize(Decimal("1." + "0" * exp))
-
-
-decimal_cases = []
-for bits in (8, 16, 32, 64, 128, 256):
-    for exp in (1, 2, 10, 18, 80):
-        max_val_fixed = (2 ** (bits - 1) - 1) / (10**exp)
-        if max_val_fixed >= 1.0:
-            decimal_cases.append((f"fixed{bits}x{exp}", make_fixed_decimal(bits, exp)))
-        max_val_ufixed = (2**bits - 1) / (10**exp)
-        if max_val_ufixed >= 1.0:
-            decimal_cases.append(
-                (f"ufixed{bits}x{exp}", make_ufixed_decimal(bits, exp))
-            )
-
-primitive_cases = (
-    [
-        ("uint8", 0),
-        ("uint8", 255),
-        ("uint16", 65535),
-        ("uint32", 2**32 - 1),
-        ("uint64", 2**64 - 1),
-        ("uint128", 2**128 - 1),
-        ("uint256", 0),
-        ("uint256", 2**256 - 1),
-        ("int8", -128),
-        ("int8", 127),
-        ("int16", -32768),
-        ("int16", 32767),
-        ("int32", -(2**31)),
-        ("int32", 2**31 - 1),
-        ("int64", -(2**63)),
-        ("int64", 2**63 - 1),
-        ("int128", -(2**127)),
-        ("int128", 2**127 - 1),
-        ("int256", -(2**255)),
-        ("int256", 2**255 - 1),
-        ("bool", True),
-        ("bool", False),
-        ("address", b"\x00" * 19 + b"\x01"),
-        ("address", b"\xff" * 20),
-        ("bytes1", b"\x01"),
-    ]
-    + [(f"bytes{M}", b"\x01" * M) for M in range(2, 33)]
-    + [
-        ("bytes", b""),
-        ("bytes", b"hello world"),
-        ("bytes", b"\x00" * 100),
-        ("bytes", b"a" * 256),
-        ("string", ""),
-        ("string", "hello world"),
-        ("string", "𝔘𝔫𝔦𝔠𝔬𝔡𝔢"),
-        ("string", "a" * 256),
-        ("string", "b" * 1024),
-    ]
-    + decimal_cases
-    + [
-        ("function", b"\x01" * 24),
-        ("function", b"\x00" * 24),
-        ("function", b"\xff" * 24),
-    ]
-)
-primitive_ids = [f"{t}-{repr(v)[:16]}" for t, v in primitive_cases]
-
-# Arrays
-array_cases = [
-    ("uint8[3]", [1, 2, 3]),
-    ("uint256[2]", [0, 2**256 - 1]),
-    ("bool[4]", [True, False, True, False]),
-    ("address[2]", [b"\x00" * 19 + b"\x01", b"\xff" * 20]),
-    ("bytes32[2]", [b"\x00" * 32, b"\xff" * 32]),
-    ("string[2]", ["foo", "bar"]),
-    ("uint8[]", [1, 2, 3, 4, 5]),
-    ("string[]", ["a", "b", "c"]),
-    ("bytes[]", [b"abc", b"def", b"ghi"]),
-    ("uint256[2][2]", [[1, 2], [3, 4]]),
-    ("bool[][2]", [[True, False], [False, True]]),
-    ("bytes8[4]", [b"\x01" * 8, b"\x02" * 8, b"\x03" * 8, b"\x04" * 8]),
-    ("fixed32x2[2]", [Decimal("3.14"), Decimal("2.71")]),
-    ("uint8[]", []),
-    ("bytes[]", []),
-    ("fixed32x2[]", []),
-    ("uint8[10]", list(range(10))),
-    ("string[5]", ["a", "b", "c", "d", "e"]),
-    ("bytes16[3]", [b"\x01" * 16, b"\x02" * 16, b"\x03" * 16]),
-    ("uint8[100]", list(range(100))),
-    ("string[10]", list(map(str, range(10)))),
-    ("bytes[10]", list(map(lambda i: i.to_bytes(8, "little"), range(10)))),
-    ("uint8[][]", [[]]),
-    ("string[]", []),
-    ("uint8[2][]", []),
-    ("uint8[2][2][]", []),
-]
-array_ids = [f"{t}-{repr(v)[:16]}" for t, v in array_cases]
-
-# Tuples
-tuple_cases = [
-    ("(uint256,bool)", (42, True)),
-    ("(address,uint8)", (b"\x00" * 19 + b"\x01", 255)),
-    ("(string,bytes)", ("foo", b"bar")),
-    ("(uint256[2],string)", ([1, 2], "baz")),
-    ("(uint8,(bool,string))", (7, (False, "hi"))),
-    ("((uint8,uint8),uint8)", ((1, 2), 3)),
-    ("(uint8[2],(string,bool[2]))", ([1, 2], ("x", [True, False]))),
-    ("(fixed32x2,uint8)", (Decimal("3.14"), 255)),
-    (
-        "(bytes1,bytes2,bytes3,bytes4)",
-        (b"\x01", b"\x01\x02", b"\x01\x02\x03", b"\x01\x02\x03\x04"),
-    ),
-    ("(function,uint256)", (b"\x01" * 24, 123)),
-    ("(uint8[3],(string[2],bool[2]))", ([1, 2, 3], (["a", "b"], [True, False]))),
-    ("(bytes32[],string[])", ([b"\x00" * 32, b"\xff" * 32], ["foo", "bar"])),
-]
-tuple_ids_full = [f"{t}-{repr(v)[:16]}" for t, v in tuple_cases]
-
-# Nested/complex
-nested_cases = [
-    ("(uint256[],(string[],bool))", ([1, 2, 3], (["a", "b"], True))),
-    ("((uint8[2],(string,bool)),bytes32)", (([1, 2], ("hi", False)), b"\x00" * 32)),
-    (
-        "(uint8[2][2],(string[2],bool[2]))",
-        ([[1, 2], [3, 4]], (["x", "y"], [True, False])),
-    ),
-    ("(uint8[2][2][2],string)", ([[[1, 2], [3, 4]], [[5, 6], [7, 8]]], "deep")),
-    (
-        "((uint8[2][2],(string[2],bool[2])),bytes32[2])",
-        (([[1, 2], [3, 4]], (["x", "y"], [True, False])), [b"\x00" * 32, b"\xff" * 32]),
-    ),
-    (
-        "(uint8[2][2][2][2],string[2])",
-        (
-            [
-                [[[1, 2], [3, 4]], [[5, 6], [7, 8]]],
-                [[[9, 10], [11, 12]], [[13, 14], [15, 16]]],
-            ],
-            ["deep", "deeper"],
-        ),
-    ),
-    (
-        "(uint8[2][2][2][2][2],string[2][2])",
-        (
-            [
-                [
-                    [[[1, 2], [3, 4]], [[5, 6], [7, 8]]],
-                    [[[9, 10], [11, 12]], [[13, 14], [15, 16]]],
-                ],
-                [
-                    [[[17, 18], [19, 20]], [[21, 22], [23, 24]]],
-                    [[[25, 26], [27, 28]], [[29, 30], [31, 32]]],
-                ],
-            ],
-            [["a", "b"], ["c", "d"]],
-        ),
-    ),
-]
-nested_ids = [f"{t}-{repr(v)[:16]}" for t, v in nested_cases]
-
-# Edge cases
-edge_cases = [
-    ("uint8[]", []),
-    ("string[]", []),
-    ("bytes", b"\x00" * 1024),
-    ("string", "a" * 1024),
-    ("(uint8[],string)", ([], "")),
-    ("(string[],bytes[])", ([""], [b""])),
-    ("bytes[]", []),
-    ("fixed32x2[]", []),
-    ("(uint8[][],string)", ([[]], "")),
-    ("(string[],bytes[])", ([], [])),
-    ("(uint8[2][],string[])", ([], [])),
-    ("(uint8[2][2][],string[])", ([], [])),
-    ("bytes[100]", list(map(lambda i: i.to_bytes(32, "little"), range(100)))),
-    ("(bytes[],string[])", ([], [])),
-    ("(uint8[2][2][2][2][],string[])", ([], [])),
-]
-edge_ids = [f"{t}-{repr(v)[:16]}" for t, v in edge_cases]
-
-# Combine all cases
-all_cases = primitive_cases + array_cases + tuple_cases + nested_cases + edge_cases
-all_ids = primitive_ids + array_ids + tuple_ids_full + nested_ids + edge_ids
-
-# Packed-compatible subset (for test_packed_benchmarks.py)
-packed_cases = [
-    ("uint256", 123456789),
-    ("address", b"\x00" * 19 + b"\x01"),
-    ("bytes", b"hello world"),
-    ("bool", True),
-    ("string", "hello world"),
-    ("(uint256,bool)", (42, False)),
-]
-packed_ids = ["uint256", "address", "bytes", "bool", "string", "tuple"]

benchmarks/test_abi_benchmarks.py

@@ -1,82 +0,0 @@
-import pytest
-
-import eth_abi
-from pytest_codspeed import (
-    BenchmarkFixture,
-)
-
-from benchmarks.batch import (
-    batch,
-)
-from benchmarks.data import (
-    all_cases,
-    all_ids,
-)
-import faster_eth_abi
-
-# --- ENCODE ---
-
-
-@pytest.mark.benchmark(group="encode")
-@pytest.mark.parametrize("abi_type,value", all_cases, ids=all_ids)
-def test_encode(benchmark: BenchmarkFixture, abi_type, value):
-    benchmark(batch, 100, eth_abi.encode, [abi_type], [value])
-
-
-@pytest.mark.benchmark(group="encode")
-@pytest.mark.parametrize("abi_type,value", all_cases, ids=all_ids)
-def test_faster_encode(benchmark: BenchmarkFixture, abi_type, value):
-    benchmark(batch, 100, faster_eth_abi.encode, [abi_type], [value])
-
-
-# --- DECODE ---
-
-decode_cases = [
-    (abi_type, faster_eth_abi.encode([abi_type], [value]))
-    for abi_type, value in all_cases
-]
-decode_ids = all_ids
-
-
-@pytest.mark.benchmark(group="decode")
-@pytest.mark.parametrize("abi_type,encoded", decode_cases, ids=decode_ids)
-def test_decode(benchmark: BenchmarkFixture, abi_type, encoded):
-    benchmark(batch, 100, eth_abi.decode, [abi_type], encoded)
-
-
-@pytest.mark.benchmark(group="decode")
-@pytest.mark.parametrize("abi_type,encoded", decode_cases, ids=decode_ids)
-def test_faster_decode(benchmark: BenchmarkFixture, abi_type, encoded):
-    benchmark(batch, 100, faster_eth_abi.decode, [abi_type], encoded)
-
-
-# --- IS_ENCODABLE ---
-
-
-@pytest.mark.benchmark(group="is_encodable")
-@pytest.mark.parametrize("abi_type,value", all_cases, ids=all_ids)
-def test_is_encodable(benchmark: BenchmarkFixture, abi_type, value):
-    benchmark(batch, 100, eth_abi.is_encodable, abi_type, value)
-
-
-@pytest.mark.benchmark(group="is_encodable")
-@pytest.mark.parametrize("abi_type,value", all_cases, ids=all_ids)
-def test_faster_is_encodable(benchmark: BenchmarkFixture, abi_type, value):
-    benchmark(batch, 100, faster_eth_abi.is_encodable, abi_type, value)
-
-
-# --- IS_ENCODABLE_TYPE ---
-
-all_types = list({abi_type for abi_type, _ in all_cases})
-
-
-@pytest.mark.benchmark(group="is_encodable_type")
-@pytest.mark.parametrize("abi_type", all_types, ids=all_types)
-def test_is_encodable_type(benchmark: BenchmarkFixture, abi_type):
-    benchmark(batch, 100, eth_abi.is_encodable_type, abi_type)
-
-
-@pytest.mark.benchmark(group="is_encodable_type")
-@pytest.mark.parametrize("abi_type", all_types, ids=all_types)
-def test_faster_is_encodable_type(benchmark: BenchmarkFixture, abi_type):
-    benchmark(batch, 100, faster_eth_abi.is_encodable_type, abi_type)

benchmarks/test_decoding_benchmarks.py

@@ -1,109 +0,0 @@
-import pytest
-
-import eth_abi
-from pytest_codspeed import (
-    BenchmarkFixture,
-)
-
-from benchmarks.batch import (
-    batch,
-)
-from benchmarks.data import (
-    addresses,
-    booleans,
-    bytes32_ids,
-    bytes32s,
-    string_ids,
-    strings,
-    tuple_ids,
-    tuples,
-    uint256s,
-)
-import faster_eth_abi
-
-booleans_encoded = [faster_eth_abi.encode(["bool"], [v]) for v in booleans]
-addresses_encoded = [faster_eth_abi.encode(["address"], [v]) for v in addresses]
-uint256s_encoded = [faster_eth_abi.encode(["uint256"], [v]) for v in uint256s]
-bytes32s_encoded = [faster_eth_abi.encode(["bytes32"], [v]) for v in bytes32s]
-strings_encoded = [faster_eth_abi.encode(["string"], [v]) for v in strings]
-tuples_encoded = [
-    (faster_eth_abi.encode(types, list(values)), types) for values, types in tuples
-]
-
-
-# Boolean decoding
-@pytest.mark.benchmark(group="BooleanDecoder")
-@pytest.mark.parametrize("value", booleans_encoded, ids=booleans)
-def test_boolean_decoder(benchmark: BenchmarkFixture, value):
-    benchmark(batch, 100, eth_abi.decode, ["bool"], value)
-
-
-@pytest.mark.benchmark(group="BooleanDecoder")
-@pytest.mark.parametrize("value", booleans_encoded, ids=booleans)
-def test_faster_boolean_decoder(benchmark: BenchmarkFixture, value):
-    benchmark(batch, 100, faster_eth_abi.decode, ["bool"], value)
-
-
-# Address decoding
-@pytest.mark.benchmark(group="AddressDecoder")
-@pytest.mark.parametrize("value", addresses_encoded, ids=addresses)
-def test_address_decoder(benchmark: BenchmarkFixture, value):
-    benchmark(batch, 100, eth_abi.decode, ["address"], value)
-
-
-@pytest.mark.benchmark(group="AddressDecoder")
-@pytest.mark.parametrize("value", addresses_encoded, ids=addresses)
-def test_faster_address_decoder(benchmark: BenchmarkFixture, value):
-    benchmark(batch, 100, faster_eth_abi.decode, ["address"], value)
-
-
-# Unsigned integer decoding
-@pytest.mark.benchmark(group="UnsignedIntegerDecoder")
-@pytest.mark.parametrize("value", uint256s_encoded, ids=uint256s)
-def test_uint256_decoder(benchmark: BenchmarkFixture, value):
-    benchmark(batch, 100, eth_abi.decode, ["uint256"], value)
-
-
-@pytest.mark.benchmark(group="UnsignedIntegerDecoder")
-@pytest.mark.parametrize("value", uint256s_encoded, ids=uint256s)
-def test_faster_uint256_decoder(benchmark: BenchmarkFixture, value):
-    benchmark(batch, 100, faster_eth_abi.decode, ["uint256"], value)
-
-
-# Bytes decoding
-@pytest.mark.benchmark(group="BytesDecoder")
-@pytest.mark.parametrize("value", bytes32s_encoded, ids=bytes32_ids)
-def test_bytes32_decoder(benchmark: BenchmarkFixture, value):
-    benchmark(batch, 100, eth_abi.decode, ["bytes32"], value)
-
-
-@pytest.mark.benchmark(group="BytesDecoder")
-@pytest.mark.parametrize("value", bytes32s_encoded, ids=bytes32_ids)
-def test_faster_bytes32_decoder(benchmark: BenchmarkFixture, value):
-    benchmark(batch, 100, faster_eth_abi.decode, ["bytes32"], value)
-
-
-# String decoding
-@pytest.mark.benchmark(group="TextStringDecoder")
-@pytest.mark.parametrize("value", strings_encoded, ids=string_ids)
-def test_string_decoder(benchmark: BenchmarkFixture, value):
-    benchmark(batch, 100, eth_abi.decode, ["string"], value)
-
-
-@pytest.mark.benchmark(group="TextStringDecoder")
-@pytest.mark.parametrize("value", strings_encoded, ids=string_ids)
-def test_faster_string_decoder(benchmark: BenchmarkFixture, value):
-    benchmark(batch, 100, faster_eth_abi.decode, ["string"], value)
-
-
-# Tuple decoding
-@pytest.mark.benchmark(group="TupleDecoder")
-@pytest.mark.parametrize("value,types", tuples_encoded, ids=tuple_ids)
-def test_tuple_decoder(benchmark: BenchmarkFixture, value, types):
-    benchmark(batch, 100, eth_abi.decode, types, value)
-
-
-@pytest.mark.benchmark(group="TupleDecoder")
-@pytest.mark.parametrize("value,types", tuples_encoded, ids=tuple_ids)
-def test_faster_tuple_decoder(benchmark: BenchmarkFixture, value, types):
-    benchmark(batch, 100, faster_eth_abi.decode, types, value)

benchmarks/test_encoding_benchmarks.py

@@ -1,99 +0,0 @@
-import pytest
-
-import eth_abi
-from pytest_codspeed import (
-    BenchmarkFixture,
-)
-
-from benchmarks.batch import (
-    batch,
-)
-from benchmarks.data import (
-    addresses,
-    booleans,
-    bytes32s,
-    string_ids,
-    strings,
-    tuple_ids,
-    tuples,
-    uint256s,
-)
-import faster_eth_abi
-
-
-# Boolean encoding
-@pytest.mark.benchmark(group="BooleanEncoder")
-@pytest.mark.parametrize("value", booleans)
-def test_boolean_encoder(benchmark: BenchmarkFixture, value):
-    benchmark(batch, 100, eth_abi.encode, ["bool"], [value])
-
-
-@pytest.mark.benchmark(group="BooleanEncoder")
-@pytest.mark.parametrize("value", booleans)
-def test_faster_boolean_encoder(benchmark: BenchmarkFixture, value):
-    benchmark(batch, 100, faster_eth_abi.encode, ["bool"], [value])
-
-
-# Address encoding
-@pytest.mark.benchmark(group="AddressEncoder")
-@pytest.mark.parametrize("value", addresses)
-def test_address_encoder(benchmark: BenchmarkFixture, value):
-    benchmark(batch, 100, eth_abi.encode, ["address"], [value])
-
-
-@pytest.mark.benchmark(group="AddressEncoder")
-@pytest.mark.parametrize("value", addresses)
-def test_faster_address_encoder(benchmark: BenchmarkFixture, value):
-    benchmark(batch, 100, faster_eth_abi.encode, ["address"], [value])
-
-
-# Unsigned integer encoding
-@pytest.mark.benchmark(group="UnsignedIntegerEncoder")
-@pytest.mark.parametrize("value", uint256s)
-def test_uint256_encoder(benchmark: BenchmarkFixture, value):
-    benchmark(batch, 100, eth_abi.encode, ["uint256"], [value])
-
-
-@pytest.mark.benchmark(group="UnsignedIntegerEncoder")
-@pytest.mark.parametrize("value", uint256s)
-def test_faster_uint256_encoder(benchmark: BenchmarkFixture, value):
-    benchmark(batch, 100, faster_eth_abi.encode, ["uint256"], [value])
-
-
-# Bytes encoding
-@pytest.mark.benchmark(group="BytesEncoder")
-@pytest.mark.parametrize("value", bytes32s)
-def test_bytes32_encoder(benchmark: BenchmarkFixture, value):
-    benchmark(batch, 100, eth_abi.encode, ["bytes32"], [value])
-
-
-@pytest.mark.benchmark(group="BytesEncoder")
-@pytest.mark.parametrize("value", bytes32s)
-def test_faster_bytes32_encoder(benchmark: BenchmarkFixture, value):
-    benchmark(batch, 100, faster_eth_abi.encode, ["bytes32"], [value])
-
-
-# String encoding
-@pytest.mark.benchmark(group="TextStringEncoder")
-@pytest.mark.parametrize("value", strings, ids=string_ids)
-def test_string_encoder(benchmark: BenchmarkFixture, value):
-    benchmark(batch, 100, eth_abi.encode, ["string"], [value])
-
-
-@pytest.mark.benchmark(group="TextStringEncoder")
-@pytest.mark.parametrize("value", strings, ids=string_ids)
-def test_faster_string_encoder(benchmark: BenchmarkFixture, value):
-    benchmark(batch, 100, faster_eth_abi.encode, ["string"], [value])
-
-
-# Tuple encoding
-@pytest.mark.benchmark(group="TupleEncoder")
-@pytest.mark.parametrize("values,types", tuples, ids=tuple_ids)
-def test_tuple_encoder(benchmark: BenchmarkFixture, values, types):
-    benchmark(batch, 100, eth_abi.encode, types, list(values))
-
-
-@pytest.mark.benchmark(group="TupleEncoder")
-@pytest.mark.parametrize("values,types", tuples, ids=tuple_ids)
-def test_faster_tuple_encoder(benchmark: BenchmarkFixture, values, types):
-    benchmark(batch, 100, faster_eth_abi.encode, types, list(values))

benchmarks/test_grammar_benchmarks.py

@@ -1,38 +0,0 @@
-import pytest
-
-import eth_abi.grammar
-from pytest_codspeed import (
-    BenchmarkFixture,
-)
-
-from benchmarks.batch import (
-    batch,
-)
-from benchmarks.type_strings import (
-    type_strings,
-)
-import faster_eth_abi.grammar
-
-
-@pytest.mark.benchmark(group="GrammarNormalize")
-@pytest.mark.parametrize("type_str", type_strings)
-def test_normalize(benchmark: BenchmarkFixture, type_str):
-    benchmark(batch, 5000, eth_abi.grammar.normalize, type_str)
-
-
-@pytest.mark.benchmark(group="GrammarNormalize")
-@pytest.mark.parametrize("type_str", type_strings)
-def test_faster_normalize(benchmark: BenchmarkFixture, type_str):
-    benchmark(batch, 5000, faster_eth_abi.grammar.normalize, type_str)
-
-
-@pytest.mark.benchmark(group="GrammarParse")
-@pytest.mark.parametrize("type_str", type_strings)
-def test_parse(benchmark: BenchmarkFixture, type_str):
-    benchmark(batch, 5000, eth_abi.grammar.parse, type_str)
-
-
-@pytest.mark.benchmark(group="GrammarParse")
-@pytest.mark.parametrize("type_str", type_strings)
-def test_faster_parse(benchmark: BenchmarkFixture, type_str):
-    benchmark(batch, 5000, faster_eth_abi.grammar.parse, type_str)