faster-eth-abi 5.2.10__tar.gz → 5.2.11__tar.gz

{faster_eth_abi-5.2.10 → faster_eth_abi-5.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: faster_eth_abi
-Version: 5.2.10
+Version: 5.2.11
 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.10 → faster_eth_abi-5.2.11}/faster_eth_abi/_codec.py

@@ -39,8 +39,6 @@ def encode_c(
     :returns: The head-tail encoded binary representation of the python
         values in ``args`` as values of the ABI types in ``types``.
     """
-    # validate encode types and args
-    validate_list_like_param(types, "types")
     validate_list_like_param(args, "args")
 
     encoder = self._registry.get_tuple_encoder(*types)
@@ -71,8 +69,6 @@ def decode_c(
     :returns: A tuple of equivalent python values for the ABI values
         represented in ``data``.
     """
-    # validate decode types and data
-    validate_list_like_param(types, "types")
     validate_bytes_param(data, "data")
 
     decoder = self._registry.get_tuple_decoder(*types, strict=strict)

faster_eth_abi-5.2.10/faster_eth_abi/grammar.py → faster_eth_abi-5.2.11/faster_eth_abi/_grammar.py

@@ -1,22 +1,22 @@
-import functools
 import re
 from typing import (
     Any,
     Final,
+    NewType,
     NoReturn,
     Optional,
     Sequence,
     Tuple,
     TypeVar,
+    Union,
     final,
 )
 
-from eth_typing import (
+from eth_typing.abi import (
     TypeStr,
 )
-import parsimonious
-from parsimonious import (
-    expressions,
+from mypy_extensions import (
+    mypyc_attr,
 )
 from parsimonious.nodes import (
     Node,
@@ -27,136 +27,29 @@ from typing_extensions import (
 
 from faster_eth_abi.exceptions import (
     ABITypeError,
-    ParseError,
 )
 
-grammar: Final = parsimonious.Grammar(
-    r"""
-    type = tuple_type / basic_type
 
-    tuple_type = components arrlist?
-    components = non_zero_tuple
-
-    non_zero_tuple = "(" type next_type* ")"
-    next_type = "," type
-
-    basic_type = base sub? arrlist?
-
-    base = alphas
-
-    sub = two_size / digits
-    two_size = (digits "x" digits)
-
-    arrlist = (const_arr / dynam_arr)+
-    const_arr = "[" digits "]"
-    dynam_arr = "[]"
+TYPE_ALIASES: Final = {
+    "int": "int256",
+    "uint": "uint256",
+    "fixed": "fixed128x18",
+    "ufixed": "ufixed128x18",
+    "function": "bytes24",
+    "byte": "bytes1",
+}
 
-    alphas = ~"[A-Za-z]+"
-    digits = ~"[1-9][0-9]*"
-    """
+TYPE_ALIAS_RE: Final = re.compile(
+    rf"\b({'|'.join(map(re.escape, TYPE_ALIASES.keys()))})\b"
 )
 
 
-@final
-class NodeVisitor(parsimonious.NodeVisitor):  # type: ignore [misc]
-    """
-    Parsimonious node visitor which performs both parsing of type strings and
-    post-processing of parse trees.  Parsing operations are cached.
-    """
-
-    def __init__(self):
-        self.parse = functools.lru_cache(maxsize=None)(self._parse_uncached)
-
-    grammar = grammar
-
-    def visit_non_zero_tuple(self, node, visited_children):
-        # Ignore left and right parens
-        _, first, rest, _ = visited_children
-
-        return (first,) + rest
-
-    def visit_tuple_type(self, node, visited_children):
-        components, arrlist = visited_children
-
-        return TupleType(components, arrlist, node=node)
-
-    def visit_next_type(self, node, visited_children):
-        # Ignore comma
-        _, abi_type = visited_children
-
-        return abi_type
-
-    def visit_basic_type(self, node, visited_children):
-        base, sub, arrlist = visited_children
-
-        return BasicType(base, sub, arrlist, node=node)
-
-    def visit_two_size(self, node, visited_children):
-        # Ignore "x"
-        first, _, second = visited_children
-
-        return first, second
-
-    def visit_const_arr(self, node, visited_children):
-        # Ignore left and right brackets
-        _, int_value, _ = visited_children
-
-        return (int_value,)
-
-    def visit_dynam_arr(self, node, visited_children):
-        return ()
-
-    def visit_alphas(self, node, visited_children):
-        return node.text
-
-    def visit_digits(self, node, visited_children):
-        return int(node.text)
-
-    def generic_visit(self, node, visited_children):
-        expr = node.expr
-        if isinstance(expr, expressions.OneOf):
-            # Unwrap value chosen from alternatives
-            return visited_children[0]
-
-        if isinstance(expr, expressions.Quantifier) and expr.min == 0 and expr.max == 1:
-            # Unwrap optional value or return `None`
-            if len(visited_children) != 0:
-                return visited_children[0]
-
-            return None
-
-        return tuple(visited_children)
-
-    def _parse_uncached(self, type_str, **kwargs):
-        """
-        Parses a type string into an appropriate instance of
-        :class:`~faster_eth_abi.grammar.ABIType`.  If a type string cannot be parsed,
-        throws :class:`~faster_eth_abi.exceptions.ParseError`.
-
-        :param type_str: The type string to be parsed.
-        :returns: An instance of :class:`~faster_eth_abi.grammar.ABIType` containing
-            information about the parsed type string.
-        """
-        if not isinstance(type_str, str):
-            raise TypeError(f"Can only parse string values: got {type(type_str)}")
-
-        try:
-            return super().parse(type_str, **kwargs)
-        except parsimonious.ParseError as e:
-            # This is a good place to add some better messaging around the type string.
-            # If this logic grows any bigger, we should abstract it to its own function.
-            if "()" in type_str:
-                # validate against zero-sized tuple types
-                raise ValueError(
-                    'Zero-sized tuple types "()" are not supported.'
-                ) from None
-
-            raise ParseError(e.text, e.pos, e.expr) from e
-
-
-visitor: Final = NodeVisitor()
+IntSubtype = NewType("IntSubtype", int)
+FixedSubtype = NewType("FixedSubtype", Tuple[int, int])
+Subtype = Union[IntSubtype, FixedSubtype]
 
 
+@mypyc_attr(allow_interpreted_subclasses=True)
 class ABIType:
     """
     Base class for results of type string parsing operations.
@@ -165,7 +58,7 @@ class ABIType:
     __slots__ = ("arrlist", "node")
 
     def __init__(
-        self, arrlist: Optional[Sequence] = None, node: Optional[Node] = None
+        self, arrlist: Optional[Sequence[str]] = None, node: Optional[Node] = None
     ) -> None:
         self.arrlist: Final = arrlist
         """
@@ -211,6 +104,7 @@ class ABIType:
         """
         raise NotImplementedError("Must implement `validate`")
 
+    @final
     def invalidate(self, error_msg: str) -> NoReturn:
         # Invalidates an ABI type with the given error message.  Expects that a
         # parsimonious node was provided from the original parsing operation
@@ -222,6 +116,7 @@ class ABIType:
             f"in '{node.full_text}': {error_msg}"
         )
 
+    @final
     @property
     def is_array(self) -> bool:
         """
@@ -238,6 +133,7 @@ class ABIType:
         """
         raise NotImplementedError("Must implement `is_dynamic`")
 
+    @final
     @property
     def _has_dynamic_arrlist(self) -> bool:
         return self.is_array and any(len(dim) == 0 for dim in self.arrlist)
@@ -246,7 +142,7 @@ class ABIType:
 TComp = TypeVar("TComp", bound=ABIType)
 
 
-@final
+@mypyc_attr(allow_interpreted_subclasses=True)
 class TupleType(ABIType):
     """
     Represents the result of parsing a tuple type string e.g. "(int,bool)".
@@ -257,7 +153,7 @@ class TupleType(ABIType):
     def __init__(
         self,
         components: Tuple[TComp, ...],
-        arrlist: Optional[Sequence] = None,
+        arrlist: Optional[Sequence[str]] = None,
         *,
         node: Optional[Node] = None,
     ) -> None:
@@ -273,7 +169,7 @@ class TupleType(ABIType):
         arrlist = self.arrlist
 
         if isinstance(arrlist, tuple):
-            arrlist = "".join(repr(list(a)) for a in arrlist)
+            arrlist = "".join(map(repr, map(list, arrlist)))
         else:
             arrlist = ""
 
@@ -286,11 +182,12 @@ class TupleType(ABIType):
                 f"Cannot determine item type for non-array type '{self.to_type_str()}'"
             )
 
-        return type(self)(
-            self.components,
-            self.arrlist[:-1] or None,  # type: ignore [index]
-            node=self.node,
-        )
+        arrlist = self.arrlist[:-1] or None  # type: ignore [index]
+        cls = type(self)
+        if cls is TupleType:
+            return TupleType(self.components, arrlist, node=self.node)  # type: ignore [return-value]
+        else:
+            return cls(self.components, arrlist, node=self.node)
 
     def validate(self) -> None:
         for c in self.components:
@@ -304,7 +201,7 @@ class TupleType(ABIType):
         return any(c.is_dynamic for c in self.components)
 
 
-@final
+@mypyc_attr(allow_interpreted_subclasses=True)
 class BasicType(ABIType):
     """
     Represents the result of parsing a basic type string e.g. "uint", "address",
@@ -316,7 +213,7 @@ class BasicType(ABIType):
     def __init__(
         self,
         base: str,
-        sub: Any = None,
+        sub: Optional[Subtype] = None,
         arrlist: Optional[Sequence] = None,
         *,
         node: Optional[Node] = None,
@@ -339,12 +236,12 @@ class BasicType(ABIType):
         if isinstance(sub, int):
             substr = str(sub)
         elif isinstance(sub, tuple):
-            substr = "x".join(str(s) for s in sub)
+            substr = "x".join(map(str, sub))
         else:
             substr = ""
 
         if isinstance(arrlist, tuple):
-            return self.base + substr + "".join(repr(list(a)) for a in arrlist)
+            return self.base + substr + "".join(map(repr, map(list, arrlist)))
         else:
             return self.base + substr
 
@@ -355,22 +252,23 @@ class BasicType(ABIType):
                 f"Cannot determine item type for non-array type '{self.to_type_str()}'"
             )
 
-        return type(self)(
-            self.base,
-            self.sub,
-            self.arrlist[:-1] or None,  # type: ignore [index]
-            node=self.node,
-        )
+        cls = type(self)
+        arrlist = self.arrlist[:-1] or None  # type: ignore [index]
+        if cls is BasicType:
+            return BasicType(self.base, self.sub, arrlist, node=self.node)  # type: ignore [return-value]
+        else:
+            return cls(self.base, self.sub, arrlist, node=self.node)
 
     @property
     def is_dynamic(self) -> bool:
         if self._has_dynamic_arrlist:
             return True
 
-        if self.base == "string":
+        base = self.base
+        if base == "string":
             return True
 
-        if self.base == "bytes" and self.sub is None:
+        if base == "bytes" and self.sub is None:
             return True
 
         return False
@@ -436,20 +334,6 @@ class BasicType(ABIType):
                 self.invalidate("address cannot have suffix")
 
 
-TYPE_ALIASES: Final = {
-    "int": "int256",
-    "uint": "uint256",
-    "fixed": "fixed128x18",
-    "ufixed": "ufixed128x18",
-    "function": "bytes24",
-    "byte": "bytes1",
-}
-
-TYPE_ALIAS_RE: Final = re.compile(
-    rf"\b({'|'.join(re.escape(a) for a in TYPE_ALIASES.keys())})\b"
-)
-
-
 def normalize(type_str: TypeStr) -> TypeStr:
     """
     Normalizes a type string into its canonical version e.g. the type string
@@ -463,6 +347,3 @@ def normalize(type_str: TypeStr) -> TypeStr:
 
 def __normalize(match: "re.Match[str]") -> str:
     return TYPE_ALIASES[match.group(0)]
-
-
-parse: Final = visitor.parse

{faster_eth_abi-5.2.10 → faster_eth_abi-5.2.11}/faster_eth_abi/codec.py

@@ -18,6 +18,7 @@ from faster_eth_abi.decoding import (
 )
 from faster_eth_abi.exceptions import (
     EncodingError,
+    MultipleEntriesFound,
 )
 from faster_eth_abi.registry import (
     ABIRegistry,
@@ -74,20 +75,18 @@ class ABIEncoder(BaseABICoder):
         :returns: ``True`` if ``arg`` is encodable as a value of the ABI type
             ``typ``.  Otherwise, ``False``.
         """
-        if not self.is_encodable_type(typ):
+        try:
+            encoder = self._registry.get_encoder(typ)
+        except MultipleEntriesFound:
+            raise
+        except:
             return False
 
-        encoder = self._registry.get_encoder(typ)
-
+        validate = getattr(encoder, "validate_value", encoder)
         try:
-            encoder.validate_value(arg)
+            validate(arg)
         except EncodingError:
             return False
-        except AttributeError:
-            try:
-                encoder(arg)
-            except EncodingError:
-                return False
 
         return True
 

{faster_eth_abi-5.2.10 → faster_eth_abi-5.2.11}/faster_eth_abi/from_type_str.py

@@ -12,11 +12,13 @@ from eth_typing import (
     TypeStr,
 )
 
-from .grammar import (
+from ._grammar import (
     ABIType,
     BasicType,
     TupleType,
     normalize,
+)
+from .grammar import (
     parse,
 )
 

faster_eth_abi-5.2.11/faster_eth_abi/grammar.py

@@ -0,0 +1,170 @@
+import functools
+import re
+from typing import (
+    Any,
+    Final,
+    NoReturn,
+    Optional,
+    Sequence,
+    Tuple,
+    TypeVar,
+    final,
+)
+
+from eth_typing import (
+    TypeStr,
+)
+import parsimonious
+from parsimonious import (
+    expressions,
+)
+from parsimonious.nodes import (
+    Node,
+)
+from typing_extensions import (
+    Self,
+)
+
+from faster_eth_abi._grammar import (
+    TYPE_ALIASES,
+    TYPE_ALIAS_RE,
+    ABIType,
+    BasicType,
+    TupleType,
+    normalize,
+)
+from faster_eth_abi.exceptions import (
+    ABITypeError,
+    ParseError,
+)
+
+grammar: Final = parsimonious.Grammar(
+    r"""
+    type = tuple_type / basic_type
+
+    tuple_type = components arrlist?
+    components = non_zero_tuple
+
+    non_zero_tuple = "(" type next_type* ")"
+    next_type = "," type
+
+    basic_type = base sub? arrlist?
+
+    base = alphas
+
+    sub = two_size / digits
+    two_size = (digits "x" digits)
+
+    arrlist = (const_arr / dynam_arr)+
+    const_arr = "[" digits "]"
+    dynam_arr = "[]"
+
+    alphas = ~"[A-Za-z]+"
+    digits = ~"[1-9][0-9]*"
+    """
+)
+
+
+@final
+class NodeVisitor(parsimonious.NodeVisitor):  # type: ignore [misc]
+    """
+    Parsimonious node visitor which performs both parsing of type strings and
+    post-processing of parse trees.  Parsing operations are cached.
+    """
+
+    def __init__(self):
+        self.parse = functools.lru_cache(maxsize=None)(self._parse_uncached)
+
+    grammar = grammar
+
+    def visit_non_zero_tuple(self, node, visited_children):
+        # Ignore left and right parens
+        _, first, rest, _ = visited_children
+
+        return (first,) + rest
+
+    def visit_tuple_type(self, node, visited_children):
+        components, arrlist = visited_children
+
+        return TupleType(components, arrlist, node=node)
+
+    def visit_next_type(self, node, visited_children):
+        # Ignore comma
+        _, abi_type = visited_children
+
+        return abi_type
+
+    def visit_basic_type(self, node, visited_children):
+        base, sub, arrlist = visited_children
+
+        return BasicType(base, sub, arrlist, node=node)
+
+    def visit_two_size(self, node, visited_children):
+        # Ignore "x"
+        first, _, second = visited_children
+
+        return first, second
+
+    def visit_const_arr(self, node, visited_children):
+        # Ignore left and right brackets
+        _, int_value, _ = visited_children
+
+        return (int_value,)
+
+    def visit_dynam_arr(self, node, visited_children):
+        return ()
+
+    def visit_alphas(self, node, visited_children):
+        return node.text
+
+    def visit_digits(self, node, visited_children):
+        return int(node.text)
+
+    def generic_visit(self, node, visited_children):
+        expr = node.expr
+        if isinstance(expr, expressions.OneOf):
+            # Unwrap value chosen from alternatives
+            return visited_children[0]
+
+        if isinstance(expr, expressions.Quantifier) and expr.min == 0 and expr.max == 1:
+            # Unwrap optional value or return `None`
+            if len(visited_children) != 0:
+                return visited_children[0]
+
+            return None
+
+        return tuple(visited_children)
+
+    def _parse_uncached(self, type_str, **kwargs):
+        """
+        Parses a type string into an appropriate instance of
+        :class:`~faster_eth_abi.grammar.ABIType`.  If a type string cannot be parsed,
+        throws :class:`~faster_eth_abi.exceptions.ParseError`.
+
+        :param type_str: The type string to be parsed.
+        :returns: An instance of :class:`~faster_eth_abi.grammar.ABIType` containing
+            information about the parsed type string.
+        """
+        if not isinstance(type_str, str):
+            raise TypeError(f"Can only parse string values: got {type(type_str)}")
+
+        try:
+            return super().parse(type_str, **kwargs)
+        except parsimonious.ParseError as e:
+            # This is a good place to add some better messaging around the type string.
+            # If this logic grows any bigger, we should abstract it to its own function.
+            if "()" in type_str:
+                # validate against zero-sized tuple types
+                raise ValueError(
+                    'Zero-sized tuple types "()" are not supported.'
+                ) from None
+
+            raise ParseError(e.text, e.pos, e.expr) from e
+
+
+visitor: Final = NodeVisitor()
+
+parse: Final = visitor.parse
+
+
+__all__ = ["NodeVisitor", "ABIType", "TupleType", "BasicType", "grammar", "parse", "normalize", "visitor", "TYPE_ALIASES", "TYPE_ALIAS_RE"]

{faster_eth_abi-5.2.10 → faster_eth_abi-5.2.11}/faster_eth_abi/registry.py

@@ -1,17 +1,24 @@
 import abc
-import copy
 import functools
+from copy import copy
 from typing import (
     Any,
     Callable,
+    Dict,
+    Final,
+    Generic,
     Optional,
     Type,
+    TypeVar,
     Union,
 )
 
 from eth_typing import (
     TypeStr,
 )
+from typing_extensions import (
+    Self,
+)
 
 from . import (
     decoding,
@@ -30,6 +37,8 @@ from .io import (
     ContextFramesBytesIO,
 )
 
+T = TypeVar("T")
+
 Lookup = Union[TypeStr, Callable[[TypeStr], bool]]
 
 EncoderCallable = Callable[[Any], bytes]
@@ -51,34 +60,35 @@ class Copyable(abc.ABC):
         return self.copy()
 
 
-class PredicateMapping(Copyable):
+class PredicateMapping(Copyable, Generic[T]):
     """
     Acts as a mapping from predicate functions to values.  Values are retrieved
     when their corresponding predicate matches a given input.  Predicates can
     also be labeled to facilitate removal from the mapping.
     """
 
-    def __init__(self, name):
-        self._name = name
-        self._values = {}
-        self._labeled_predicates = {}
+    def __init__(self, name: str):
+        self._name: Final = name
+        self._values: Dict[Lookup, T] = {}
+        self._labeled_predicates: Dict[str, Lookup] = {}
 
-    def add(self, predicate, value, label=None):
+    def add(self, predicate: Lookup, value: T, label: Optional[str] = None) -> None:
         if predicate in self._values:
             raise ValueError(f"Matcher {predicate!r} already exists in {self._name}")
 
         if label is not None:
-            if label in self._labeled_predicates:
+            labeled_predicates = self._labeled_predicates
+            if label in labeled_predicates:
                 raise ValueError(
                     f"Matcher {predicate!r} with label '{label}' "
                     f"already exists in {self._name}"
                 )
 
-            self._labeled_predicates[label] = predicate
+            labeled_predicates[label] = predicate
 
         self._values[predicate] = value
 
-    def find(self, type_str):
+    def find(self, type_str: TypeStr) -> T:
         results = tuple(
             (predicate, value)
             for predicate, value in self._values.items()
@@ -103,9 +113,9 @@ class PredicateMapping(Copyable):
                 "documentation for more information."
             )
 
-        return values[0]
+        return values[0]  # type: ignore [no-any-return]
 
-    def remove_by_equality(self, predicate):
+    def remove_by_equality(self, predicate: Lookup) -> None:
         # Delete the predicate mapping to the previously stored value
         try:
             del self._values[predicate]
@@ -120,7 +130,7 @@ class PredicateMapping(Copyable):
         else:
             del self._labeled_predicates[label]
 
-    def _label_for_predicate(self, predicate):
+    def _label_for_predicate(self, predicate: Lookup) -> str:
         # Both keys and values in `_labeled_predicates` are unique since the
         # `add` method enforces this
         for key, value in self._labeled_predicates.items():
@@ -131,16 +141,17 @@ class PredicateMapping(Copyable):
             f"Matcher {predicate!r} not referred to by any label in {self._name}"
         )
 
-    def remove_by_label(self, label):
+    def remove_by_label(self, label: str) -> None:
+        labeled_predicates = self._labeled_predicates
         try:
-            predicate = self._labeled_predicates[label]
+            predicate = labeled_predicates[label]
         except KeyError:
             raise KeyError(f"Label '{label}' not found in {self._name}")
 
-        del self._labeled_predicates[label]
+        del labeled_predicates[label]
         del self._values[predicate]
 
-    def remove(self, predicate_or_label):
+    def remove(self, predicate_or_label: Union[Lookup, str]) -> None:
         if callable(predicate_or_label):
             self.remove_by_equality(predicate_or_label)
         elif isinstance(predicate_or_label, str):
@@ -151,11 +162,11 @@ class PredicateMapping(Copyable):
                 f"{type(predicate_or_label)}"
             )
 
-    def copy(self):
+    def copy(self) -> Self:
         cpy = type(self)(self._name)
 
-        cpy._values = copy.copy(self._values)
-        cpy._labeled_predicates = copy.copy(self._labeled_predicates)
+        cpy._values = copy(self._values)
+        cpy._labeled_predicates = copy(self._labeled_predicates)
 
         return cpy
 
@@ -282,6 +293,7 @@ def _clear_encoder_cache(old_method: Callable[..., None]) -> Callable[..., None]
     @functools.wraps(old_method)
     def new_method(self: "ABIRegistry", *args: Any, **kwargs: Any) -> None:
         self.get_encoder.cache_clear()
+        self.get_tuple_encoder.cache_clear()
         return old_method(self, *args, **kwargs)
 
     return new_method
@@ -291,6 +303,7 @@ def _clear_decoder_cache(old_method: Callable[..., None]) -> Callable[..., None]
     @functools.wraps(old_method)
     def new_method(self: "ABIRegistry", *args: Any, **kwargs: Any) -> None:
         self.get_decoder.cache_clear()
+        self.get_tuple_decoder.cache_clear()
         return old_method(self, *args, **kwargs)
 
     return new_method
@@ -343,8 +356,8 @@ class BaseRegistry:
 
 class ABIRegistry(Copyable, BaseRegistry):
     def __init__(self):
-        self._encoders = PredicateMapping("encoder registry")
-        self._decoders = PredicateMapping("decoder registry")
+        self._encoders: PredicateMapping[Encoder] = PredicateMapping("encoder registry")
+        self._decoders: PredicateMapping[Decoder] = PredicateMapping("decoder registry")
         self.get_encoder = functools.lru_cache(maxsize=None)(self._get_encoder_uncached)
         self.get_decoder = functools.lru_cache(maxsize=None)(self._get_decoder_uncached)
         self.get_tuple_encoder = functools.lru_cache(maxsize=None)(
@@ -518,8 +531,8 @@ class ABIRegistry(Copyable, BaseRegistry):
         """
         cpy = type(self)()
 
-        cpy._encoders = copy.copy(self._encoders)
-        cpy._decoders = copy.copy(self._decoders)
+        cpy._encoders = copy(self._encoders)
+        cpy._decoders = copy(self._decoders)
 
         return cpy
 

{faster_eth_abi-5.2.10 → faster_eth_abi-5.2.11}/faster_eth_abi/tools/_strategies.py

@@ -2,7 +2,9 @@ from typing import (
     Callable,
     Final,
     Optional,
+    Tuple,
     Union,
+    cast,
 )
 
 from cchecksum import (
@@ -15,11 +17,13 @@ from hypothesis import (
     strategies as st,
 )
 
-from faster_eth_abi.grammar import (
+from faster_eth_abi._grammar import (
     ABIType,
     BasicType,
     TupleType,
     normalize,
+)
+from faster_eth_abi.grammar import (
     parse,
 )
 from faster_eth_abi.registry import (
@@ -81,7 +85,7 @@ class StrategyRegistry(BaseRegistry):
 def get_uint_strategy(
     abi_type: BasicType, registry: StrategyRegistry
 ) -> st.SearchStrategy:
-    bits = abi_type.sub
+    bits = cast(int, abi_type.sub)
 
     return st.integers(
         min_value=0,
@@ -92,7 +96,7 @@ def get_uint_strategy(
 def get_int_strategy(
     abi_type: BasicType, registry: StrategyRegistry
 ) -> st.SearchStrategy:
-    bits = abi_type.sub
+    bits = cast(int, abi_type.sub)
 
     return st.integers(
         min_value=-(2 ** (bits - 1)),
@@ -107,7 +111,7 @@ bool_strategy: Final = st.booleans()
 def get_ufixed_strategy(
     abi_type: BasicType, registry: StrategyRegistry
 ) -> st.SearchStrategy:
-    bits, places = abi_type.sub
+    bits, places = cast(Tuple[int, int], abi_type.sub)
 
     return st.decimals(
         min_value=0,
@@ -119,7 +123,7 @@ def get_ufixed_strategy(
 def get_fixed_strategy(
     abi_type: BasicType, registry: StrategyRegistry
 ) -> st.SearchStrategy:
-    bits, places = abi_type.sub
+    bits, places = cast(Tuple[int, int], abi_type.sub)
 
     return st.decimals(
         min_value=-(2 ** (bits - 1)),

{faster_eth_abi-5.2.10 → faster_eth_abi-5.2.11}/faster_eth_abi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: faster-eth-abi
-Version: 5.2.10
+Version: 5.2.11
 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.10 → faster_eth_abi-5.2.11}/faster_eth_abi.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ faster_eth_abi/__init__.py
 faster_eth_abi/_codec.py
 faster_eth_abi/_decoding.py
 faster_eth_abi/_encoding.py
+faster_eth_abi/_grammar.py
 faster_eth_abi/abi.py
 faster_eth_abi/base.py
 faster_eth_abi/codec.py

faster_eth_abi-5.2.11/faster_eth_abi.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+29859a9e7da9d19bb98c__mypyc
+faster_eth_abi

{faster_eth_abi-5.2.10 → faster_eth_abi-5.2.11}/pyproject.toml

@@ -5,8 +5,8 @@ requires = [
 	"mypy[mypyc]>=1.14.1,<1.18.3",
 	"mypy_extensions",
 	"cchecksum>=0.2.6,<0.4",
- 	# pydantic-core (installed with faster-eth-utils) is unable to build on Python3.14
-	"faster-eth-utils>=2.0.0; python_version<'3.14'",
+	# pydantic-core (installed with faster-eth-utils) is unable to build on Python3.14 on 32-bit Linux distros
+	"faster-eth-utils>=2.0.0; platform_system != 'Linux' or python_version != '3.14' or platform_machine != 'i686'",
 	"eth-typing>=3.0.0",
 	"parsimonious>=0.10.0,<0.11.0",
 ]

{faster_eth_abi-5.2.10 → faster_eth_abi-5.2.11}/setup.py

@@ -55,6 +55,7 @@ ext_modules = mypycify(
         "faster_eth_abi/_codec.py",
         "faster_eth_abi/_decoding.py",
         "faster_eth_abi/_encoding.py",
+        "faster_eth_abi/_grammar.py",
         "faster_eth_abi/abi.py",
         "faster_eth_abi/constants.py",
         "faster_eth_abi/from_type_str.py",
@@ -73,7 +74,7 @@ ext_modules = mypycify(
 setup(
     name="faster_eth_abi",
     # *IMPORTANT*: Don't manually change the version here. See Contributing docs for the release process.
-    version="5.2.10",
+    version="5.2.11",
     description="""A faster fork of eth_abi: Python utilities for working with Ethereum ABI definitions, especially encoding and decoding. Implemented in C.""",
     long_description=long_description,
     long_description_content_type="text/markdown",

{faster_eth_abi-5.2.10 → faster_eth_abi-5.2.11}/tests/core/abi_tests/test_decode.py

@@ -7,6 +7,7 @@ from faster_eth_abi.abi import (
 from faster_eth_abi.exceptions import (
     InsufficientDataBytes,
     InvalidPointer,
+    NoEntriesFound,
 )
 from faster_eth_abi.grammar import (
     parse,
@@ -90,9 +91,9 @@ def test_abi_decode_wrong_data_param_type_raises(data, strict):
 @pytest.mark.parametrize(
     "types",
     (
-        "",
+        # "",  This parametrization is disabled because we don't type check `types` and when iterated upon, `""` yields no items and ends iteration.
         123,
-        b"",
+        # b"",  This parametrization is disabled because we don't type check `types` and when iterated upon, `""` yields no items and ends iteration.
         b"\xff",
         b"david attenborough",
         bytearray(b"\x01\xff"),
@@ -101,9 +102,15 @@ def test_abi_decode_wrong_data_param_type_raises(data, strict):
     ),
 )
 def test_abi_decode_wrong_types_param_type_raises(types, strict):
+    if types == {"key": "val"}:
+        expected_exc = NoEntriesFound
+    else:
+        expected_exc = TypeError
     with pytest.raises(
-        TypeError,
-        match=f"The `types` value type must be one of list or tuple. Got {type(types)}",
+        expected_exc,
+        # NOTE The `match` arg was commented out because faster-eth-abi might not raise
+        # the same exception, but we should still test that it raises an Exception like eth-abi
+        # match=f"The `types` value type must be one of list or tuple. Got {type(types)}",
     ):
         decode(types, b"\x00" * 32, strict=strict)
 

{faster_eth_abi-5.2.10 → faster_eth_abi-5.2.11}/tests/core/abi_tests/test_encode.py

@@ -4,6 +4,10 @@ import re
 from faster_eth_abi import (
     encode,
 )
+from faster_eth_abi.exceptions import (
+    NoEntriesFound,
+    ValueOutOfBounds,
+)
 from faster_eth_abi.grammar import (
     parse,
 )
@@ -101,10 +105,17 @@ def test_abi_encode_for_single_dynamic_types(
 )
 def test_abi_encode_raises_for_non_list_like_params(non_list_like_value):
     # test raises when `types` param is not list-like
+    if non_list_like_value in ("", b""):
+        expected_exc = ValueOutOfBounds
+    elif non_list_like_value == {"key": "val"}:
+        expected_exc = NoEntriesFound
+    else:
+        expected_exc = TypeError
     with pytest.raises(
-        TypeError,
-        match=f"The `types` value type must be one of list or tuple. "
-        f"Got {type(non_list_like_value)}",
+        expected_exc,
+        # NOTE The `match` arg was commented out because faster-eth-abi might not raise
+        # the same exception, but we should still test that it raises an Exception like eth-abi
+        # match=f"The `types` value type must be one of list or tuple. Got {type(non_list_like_value)}",
     ):
         encode(non_list_like_value, ["bytes"])
 

faster_eth_abi-5.2.10/faster_eth_abi.egg-info/top_level.txt

@@ -1,2 +0,0 @@
-76f9a3652d4d2667c55c__mypyc
-faster_eth_abi