faster-eth-abi 5.2.3__cp310-cp310-win_amd64.whl → 5.2.19__cp310-cp310-win_amd64.whl

faster_eth_abi/registry.py

@@ -1,17 +1,35 @@
+"""Registry and predicate logic for ABI encoders and decoders.
+
+Implements registration, lookup, and matching of encoders and decoders for ABI type strings.
+"""
 import abc
-import copy
+from copy import (
+    copy,
+)
 import functools
 from typing import (
     Any,
     Callable,
+    Dict,
+    Final,
+    Generic,
+    Iterator,
     Optional,
     Type,
+    TypeVar,
     Union,
+    cast,
+    final,
 )
 
 from eth_typing import (
     TypeStr,
 )
+from typing_extensions import (
+    Concatenate,
+    ParamSpec,
+    Self,
+)
 
 from . import (
     decoding,
@@ -30,6 +48,9 @@ from .io import (
     ContextFramesBytesIO,
 )
 
+T = TypeVar("T")
+P = ParamSpec("P")
+
 Lookup = Union[TypeStr, Callable[[TypeStr], bool]]
 
 EncoderCallable = Callable[[Any], bytes]
@@ -41,44 +62,45 @@ Decoder = Union[DecoderCallable, Type[decoding.BaseDecoder]]
 
 class Copyable(abc.ABC):
     @abc.abstractmethod
-    def copy(self):
+    def copy(self) -> Self:
         pass
 
-    def __copy__(self):
+    def __copy__(self) -> Self:
         return self.copy()
 
-    def __deepcopy__(self, *args):
+    def __deepcopy__(self, *args: Any) -> Self:
         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 +125,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 +142,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 +153,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,61 +174,79 @@ 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
 
 
-class Predicate:
+class Predicate(Generic[T]):
     """
     Represents a predicate function to be used for type matching in
     ``ABIRegistry``.
     """
 
-    __slots__ = tuple()
+    __slots__ = ("_string", "__hash")
+
+    _string: Optional[str]
+
+    def __init__(self) -> None:
+        self._string = None
+        self.__hash = None
 
-    def __call__(self, *args, **kwargs):  # pragma: no cover
+    def __call__(self, arg: TypeStr) -> None:
         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):
-        for attr in self.__slots__:
-            yield getattr(self, attr)
+    def __iter__(self) -> Iterator[T]:
+        raise NotImplementedError("must be implemented by subclass")
 
-    def __hash__(self):
-        return hash(tuple(self))
+    def __hash__(self) -> int:
+        hashval = self.__hash
+        if hashval is None:
+            self.__hash = hashval = hash(tuple(self))
+        return hashval
 
-    def __eq__(self, other):
+    def __eq__(self, other: "Predicate") -> bool:
         return type(self) is type(other) and tuple(self) == tuple(other)
 
 
-class Equals(Predicate):
+@final
+class Equals(Predicate[str]):
     """
     A predicate that matches any input equal to `value`.
     """
 
     __slots__ = ("value",)
 
-    def __init__(self, value):
-        self.value = value
+    def __init__(self, value: str) -> None:
+        super().__init__()
+        self.value: Final = value
 
-    def __call__(self, other):
+    def __call__(self, other: TypeStr) -> bool:
         return self.value == other
 
-    def __str__(self):
-        return f"(== {self.value!r})"
+    def __str__(self) -> str:
+        # NOTE should this just be done at init time? is it always called?
+        string = self._string
+        if string is None:
+            self._string = string = f"(== {self.value!r})"
+        return string
 
+    def __iter__(self) -> Iterator[str]:
+        yield self.value
 
-class BaseEquals(Predicate):
+
+@final
+class BaseEquals(Predicate[Union[str, bool, None]]):
     """
     A predicate that matches a basic type string with a base component equal to
     `value` and no array component.  If `with_sub` is `True`, the type string
@@ -216,11 +257,12 @@ class BaseEquals(Predicate):
 
     __slots__ = ("base", "with_sub")
 
-    def __init__(self, base, *, with_sub=None):
-        self.base = base
-        self.with_sub = with_sub
+    def __init__(self, base: TypeStr, *, with_sub: Optional[bool] = None):
+        super().__init__()
+        self.base: Final = base
+        self.with_sub: Final = 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):
@@ -230,10 +272,12 @@ class BaseEquals(Predicate):
             if abi_type.arrlist is not None:
                 return False
 
-            if self.with_sub is not None:
-                if self.with_sub and abi_type.sub is None:
+            with_sub = self.with_sub
+            if with_sub is not None:
+                abi_subtype = abi_type.sub
+                if with_sub and abi_subtype is None:
                     return False
-                if not self.with_sub and abi_type.sub is not None:
+                if not with_sub and abi_subtype is not None:
                     return False
 
             return abi_type.base == self.base
@@ -242,19 +286,25 @@ class BaseEquals(Predicate):
         # e.g. if it contained a tuple type
         return False
 
-    def __str__(self):
-        return (
-            f"(base == {self.base!r}"
-            + (
-                ""
-                if self.with_sub is None
-                else (" and sub is not None" if self.with_sub else " and sub is None")
-            )
-            + ")"
-        )
-
-
-def has_arrlist(type_str):
+    def __str__(self) -> str:
+        # NOTE should this just be done at init time? is it always called?
+        string = self._string
+        if string is None:
+            if self.with_sub is None:
+                string = f"(base == {self.base!r})"
+            elif self.with_sub:
+                string = f"(base == {self.base!r} and sub is not None)"
+            else:
+                string = f"(base == {self.base!r} and sub is None)"
+            self._string = string
+        return string
+
+    def __iter__(self) -> Iterator[Union[str, bool, None]]:
+        yield self.base
+        yield self.with_sub
+
+
+def has_arrlist(type_str: TypeStr) -> bool:
     """
     A predicate that matches a type string with an array dimension list.
     """
@@ -266,7 +316,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.
     """
@@ -278,19 +328,25 @@ 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)
 
     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)
 
     return new_method
@@ -298,7 +354,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
@@ -312,7 +373,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
@@ -327,7 +388,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:
@@ -342,19 +403,25 @@ class BaseRegistry:
 
 
 class ABIRegistry(Copyable, BaseRegistry):
-    def __init__(self):
-        self._encoders = PredicateMapping("encoder registry")
-        self._decoders = PredicateMapping("decoder registry")
+    def __init__(self) -> None:
+        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)(
+            self._get_tuple_encoder_uncached
+        )
+        self.get_tuple_decoder = functools.lru_cache(maxsize=None)(
+            self._get_tuple_decoder_uncached
+        )
 
-    def _get_registration(self, mapping, type_str):
+    def _get_registration(self, mapping: PredicateMapping[T], type_str: TypeStr) -> T:
         coder = super()._get_registration(mapping, type_str)
 
         if isinstance(coder, type) and issubclass(coder, BaseCoder):
             return coder.from_type_str(type_str, self)
 
-        return coder
+        return cast(T, coder)
 
     @_clear_encoder_cache
     def register_encoder(
@@ -454,9 +521,16 @@ class ABIRegistry(Copyable, BaseRegistry):
         self.unregister_encoder(label)
         self.unregister_decoder(label)
 
-    def _get_encoder_uncached(self, type_str):
+    def _get_encoder_uncached(self, type_str: TypeStr) -> Encoder:
         return self._get_registration(self._encoders, type_str)
 
+    def _get_tuple_encoder_uncached(
+        self,
+        *type_strs: TypeStr,
+    ) -> encoding.TupleEncoder:
+        encoders = tuple(map(self.get_encoder, type_strs))
+        return encoding.TupleEncoder(encoders=encoders)
+
     def has_encoder(self, type_str: TypeStr) -> bool:
         """
         Returns ``True`` if an encoder is found for the given type string
@@ -473,7 +547,7 @@ class ABIRegistry(Copyable, BaseRegistry):
 
         return True
 
-    def _get_decoder_uncached(self, type_str, strict=True):
+    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:
@@ -484,7 +558,18 @@ class ABIRegistry(Copyable, BaseRegistry):
 
         return decoder
 
-    def copy(self):
+    def _get_tuple_decoder_uncached(
+        self,
+        *type_strs: TypeStr,
+        strict: bool = True,
+    ) -> decoding.TupleDecoder:
+        decoders = tuple(
+            self.get_decoder(type_str, strict)
+            for type_str in type_strs
+        )
+        return decoding.TupleDecoder(decoders=decoders)
+
+    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
@@ -495,22 +580,43 @@ 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
 
 
 registry = ABIRegistry()
 
+is_int = BaseEquals("int")
+is_int8 = Equals("int8")
+is_int16 = Equals("int16")
+is_uint = BaseEquals("uint")
+is_uint8 = Equals("uint8")
+is_uint16 = Equals("uint16")
+
+for size in (8, 16):
+    registry.register(
+        Equals(f"uint{size}"),
+        encoding.UnsignedIntegerEncoder,
+        decoding.UnsignedIntegerDecoder,
+        label=f"uint{size}",
+    )
+    registry.register(
+        Equals(f"int{size}"),
+        encoding.SignedIntegerEncoder,
+        decoding.SignedIntegerDecoder,
+        label=f"int{size}",
+    )
+
 registry.register(
-    BaseEquals("uint"),
+    lambda s: is_uint(s) and not is_uint8(s) and not is_uint16(s),
     encoding.UnsignedIntegerEncoder,
     decoding.UnsignedIntegerDecoder,
     label="uint",
 )
 registry.register(
-    BaseEquals("int"),
+    lambda s: is_int(s) and not is_int8(s) and not is_int16(s),
     encoding.SignedIntegerEncoder,
     decoding.SignedIntegerDecoder,
     label="int",
@@ -578,13 +684,25 @@ registry.register(
 
 registry_packed = ABIRegistry()
 
+for size in (8, 16):
+    registry_packed.register_encoder(
+        Equals(f"uint{size}"),
+        encoding.PackedUnsignedIntegerEncoderCached,
+        label=f"uint{size}",
+    )
+    registry_packed.register_encoder(
+        Equals(f"int{size}"),
+        encoding.PackedSignedIntegerEncoderCached,
+        label=f"int{size}",
+    )
+
 registry_packed.register_encoder(
-    BaseEquals("uint"),
+    lambda s: is_uint(s) and not is_uint8(s) and not is_uint16(s),
     encoding.PackedUnsignedIntegerEncoder,
     label="uint",
 )
 registry_packed.register_encoder(
-    BaseEquals("int"),
+    lambda s: is_int(s) and not is_int8(s) and not is_int16(s),
     encoding.PackedSignedIntegerEncoder,
     label="int",
 )

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,14 @@ from hypothesis import (
     strategies as st,
 )
 
-from faster_eth_abi.grammar import (
+from faster_eth_abi._grammar import (
     ABIType,
+    Arrlist,
     BasicType,
     TupleType,
     normalize,
+)
+from faster_eth_abi.grammar import (
     parse,
 )
 from faster_eth_abi.registry import (
@@ -81,7 +86,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 +97,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 +112,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 +124,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)),
@@ -150,7 +155,8 @@ def get_array_strategy(
     item_type_str = item_type.to_type_str()
     item_strategy = registry.get_strategy(item_type_str)
 
-    last_dim = abi_type.arrlist[-1]  # type: ignore [index]
+    arrlist = cast(Arrlist, abi_type.arrlist)
+    last_dim = cast(Tuple[int, ...], arrlist[-1])
     if len(last_dim) == 0:
         # Is dynamic list.  Don't restrict length.
         return st.lists(item_strategy)