coinex-api 0.0.12__py3-none-any.whl → 0.0.14__py3-none-any.whl

coinex/ccxt/static_dependencies/ethereum/abi/registry.py

@@ -0,0 +1,643 @@
+import abc
+import copy
+import functools
+from typing import (
+    Any,
+    Callable,
+    Type,
+    Union,
+)
+
+from ..typing import (
+    abi,
+)
+
+from . import (
+    decoding,
+    encoding,
+    exceptions,
+    grammar,
+)
+from .base import (
+    BaseCoder,
+)
+from .exceptions import (
+    ABITypeError,
+    MultipleEntriesFound,
+    NoEntriesFound,
+)
+
+Lookup = Union[abi.TypeStr, Callable[[abi.TypeStr], bool]]
+
+EncoderCallable = Callable[[Any], bytes]
+DecoderCallable = Callable[[decoding.ContextFramesBytesIO], Any]
+
+Encoder = Union[EncoderCallable, Type[encoding.BaseEncoder]]
+Decoder = Union[DecoderCallable, Type[decoding.BaseDecoder]]
+
+
+class Copyable(abc.ABC):
+    @abc.abstractmethod
+    def copy(self):
+        pass
+
+    def __copy__(self):
+        return self.copy()
+
+    def __deepcopy__(self, *args):
+        return self.copy()
+
+
+class PredicateMapping(Copyable):
+    """
+    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 add(self, predicate, value, label=None):
+        if predicate in self._values:
+            raise ValueError(
+                "Matcher {} already exists in {}".format(
+                    repr(predicate),
+                    self._name,
+                )
+            )
+
+        if label is not None:
+            if label in self._labeled_predicates:
+                raise ValueError(
+                    "Matcher {} with label '{}' already exists in {}".format(
+                        repr(predicate),
+                        label,
+                        self._name,
+                    ),
+                )
+
+            self._labeled_predicates[label] = predicate
+
+        self._values[predicate] = value
+
+    def find(self, type_str):
+        results = tuple(
+            (predicate, value)
+            for predicate, value in self._values.items()
+            if predicate(type_str)
+        )
+
+        if len(results) == 0:
+            raise NoEntriesFound(
+                "No matching entries for '{}' in {}".format(
+                    type_str,
+                    self._name,
+                )
+            )
+
+        predicates, values = tuple(zip(*results))
+
+        if len(results) > 1:
+            predicate_reprs = ", ".join(map(repr, predicates))
+            raise MultipleEntriesFound(
+                f"Multiple matching entries for '{type_str}' in {self._name}: "
+                f"{predicate_reprs}. This occurs when two registrations match the "
+                "same type string. You may need to delete one of the "
+                "registrations or modify its matching behavior to ensure it "
+                'doesn\'t collide with other registrations. See the "Registry" '
+                "documentation for more information."
+            )
+
+        return values[0]
+
+    def remove_by_equality(self, predicate):
+        # Delete the predicate mapping to the previously stored value
+        try:
+            del self._values[predicate]
+        except KeyError:
+            raise KeyError(
+                "Matcher {} not found in {}".format(
+                    repr(predicate),
+                    self._name,
+                )
+            )
+
+        # Delete any label which refers to this predicate
+        try:
+            label = self._label_for_predicate(predicate)
+        except ValueError:
+            pass
+        else:
+            del self._labeled_predicates[label]
+
+    def _label_for_predicate(self, predicate):
+        # Both keys and values in `_labeled_predicates` are unique since the
+        # `add` method enforces this
+        for key, value in self._labeled_predicates.items():
+            if value is predicate:
+                return key
+
+        raise ValueError(
+            "Matcher {} not referred to by any label in {}".format(
+                repr(predicate),
+                self._name,
+            )
+        )
+
+    def remove_by_label(self, label):
+        try:
+            predicate = self._labeled_predicates[label]
+        except KeyError:
+            raise KeyError("Label '{}' not found in {}".format(label, self._name))
+
+        del self._labeled_predicates[label]
+        del self._values[predicate]
+
+    def remove(self, predicate_or_label):
+        if callable(predicate_or_label):
+            self.remove_by_equality(predicate_or_label)
+        elif isinstance(predicate_or_label, str):
+            self.remove_by_label(predicate_or_label)
+        else:
+            raise TypeError(
+                "Key to be removed must be callable or string: got {}".format(
+                    type(predicate_or_label),
+                )
+            )
+
+    def copy(self):
+        cpy = type(self)(self._name)
+
+        cpy._values = copy.copy(self._values)
+        cpy._labeled_predicates = copy.copy(self._labeled_predicates)
+
+        return cpy
+
+
+class Predicate:
+    """
+    Represents a predicate function to be used for type matching in
+    ``ABIRegistry``.
+    """
+
+    __slots__ = tuple()
+
+    def __call__(self, *args, **kwargs):  # pragma: no cover
+        raise NotImplementedError("Must implement `__call__`")
+
+    def __str__(self):  # pragma: no cover
+        raise NotImplementedError("Must implement `__str__`")
+
+    def __repr__(self):
+        return "<{} {}>".format(type(self).__name__, self)
+
+    def __iter__(self):
+        for attr in self.__slots__:
+            yield getattr(self, attr)
+
+    def __hash__(self):
+        return hash(tuple(self))
+
+    def __eq__(self, other):
+        return type(self) is type(other) and tuple(self) == tuple(other)
+
+
+class Equals(Predicate):
+    """
+    A predicate that matches any input equal to `value`.
+    """
+
+    __slots__ = ("value",)
+
+    def __init__(self, value):
+        self.value = value
+
+    def __call__(self, other):
+        return self.value == other
+
+    def __str__(self):
+        return "(== {})".format(repr(self.value))
+
+
+class BaseEquals(Predicate):
+    """
+    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
+    must have a sub component to match.  If `with_sub` is `False`, the type
+    string must *not* have a sub component to match.  If `with_sub` is None,
+    the type string's sub component is ignored.
+    """
+
+    __slots__ = ("base", "with_sub")
+
+    def __init__(self, base, *, with_sub=None):
+        self.base = base
+        self.with_sub = with_sub
+
+    def __call__(self, type_str):
+        try:
+            abi_type = grammar.parse(type_str)
+        except exceptions.ParseError:
+            return False
+
+        if isinstance(abi_type, grammar.BasicType):
+            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:
+                    return False
+                if not self.with_sub and abi_type.sub is not None:
+                    return False
+
+            return abi_type.base == self.base
+
+        # We'd reach this point if `type_str` did not contain a basic type
+        # e.g. if it contained a tuple type
+        return False
+
+    def __str__(self):
+        return "(base == {}{})".format(
+            repr(self.base),
+            ""
+            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):
+    """
+    A predicate that matches a type string with an array dimension list.
+    """
+    try:
+        abi_type = grammar.parse(type_str)
+    except exceptions.ParseError:
+        return False
+
+    return abi_type.arrlist is not None
+
+
+def is_base_tuple(type_str):
+    """
+    A predicate that matches a tuple type with no array dimension list.
+    """
+    try:
+        abi_type = grammar.parse(type_str)
+    except exceptions.ParseError:
+        return False
+
+    return isinstance(abi_type, grammar.TupleType) and abi_type.arrlist is None
+
+
+def _clear_encoder_cache(old_method):
+    @functools.wraps(old_method)
+    def new_method(self, *args, **kwargs):
+        self.get_encoder.cache_clear()
+        return old_method(self, *args, **kwargs)
+
+    return new_method
+
+
+def _clear_decoder_cache(old_method):
+    @functools.wraps(old_method)
+    def new_method(self, *args, **kwargs):
+        self.get_decoder.cache_clear()
+        return old_method(self, *args, **kwargs)
+
+    return new_method
+
+
+class BaseRegistry:
+    @staticmethod
+    def _register(mapping, lookup, value, label=None):
+        if callable(lookup):
+            mapping.add(lookup, value, label)
+            return
+
+        if isinstance(lookup, str):
+            mapping.add(Equals(lookup), value, lookup)
+            return
+
+        raise TypeError(
+            "Lookup must be a callable or a value of type `str`: got {}".format(
+                repr(lookup),
+            )
+        )
+
+    @staticmethod
+    def _unregister(mapping, lookup_or_label):
+        if callable(lookup_or_label):
+            mapping.remove_by_equality(lookup_or_label)
+            return
+
+        if isinstance(lookup_or_label, str):
+            mapping.remove_by_label(lookup_or_label)
+            return
+
+        raise TypeError(
+            "Lookup/label must be a callable or a value of type `str`: got {}".format(
+                repr(lookup_or_label),
+            )
+        )
+
+    @staticmethod
+    def _get_registration(mapping, type_str):
+        try:
+            value = mapping.find(type_str)
+        except ValueError as e:
+            if "No matching" in e.args[0]:
+                # If no matches found, attempt to parse in case lack of matches
+                # was due to unparsability
+                grammar.parse(type_str)
+
+            raise
+
+        return value
+
+
+class ABIRegistry(Copyable, BaseRegistry):
+    def __init__(self):
+        self._encoders = PredicateMapping("encoder registry")
+        self._decoders = PredicateMapping("decoder registry")
+
+    def _get_registration(self, mapping, type_str):
+        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
+
+    @_clear_encoder_cache
+    def register_encoder(
+        self, lookup: Lookup, encoder: Encoder, label: str = None
+    ) -> None:
+        """
+        Registers the given ``encoder`` under the given ``lookup``.  A unique
+        string label may be optionally provided that can be used to refer to
+        the registration by name.  For more information about arguments, refer
+        to :any:`register`.
+        """
+        self._register(self._encoders, lookup, encoder, label=label)
+
+    @_clear_encoder_cache
+    def unregister_encoder(self, lookup_or_label: Lookup) -> None:
+        """
+        Unregisters an encoder in the registry with the given lookup or label.
+        If ``lookup_or_label`` is a string, the encoder with the label
+        ``lookup_or_label`` will be unregistered.  If it is an function, the
+        encoder with the lookup function ``lookup_or_label`` will be
+        unregistered.
+        """
+        self._unregister(self._encoders, lookup_or_label)
+
+    @_clear_decoder_cache
+    def register_decoder(
+        self, lookup: Lookup, decoder: Decoder, label: str = None
+    ) -> None:
+        """
+        Registers the given ``decoder`` under the given ``lookup``.  A unique
+        string label may be optionally provided that can be used to refer to
+        the registration by name.  For more information about arguments, refer
+        to :any:`register`.
+        """
+        self._register(self._decoders, lookup, decoder, label=label)
+
+    @_clear_decoder_cache
+    def unregister_decoder(self, lookup_or_label: Lookup) -> None:
+        """
+        Unregisters a decoder in the registry with the given lookup or label.
+        If ``lookup_or_label`` is a string, the decoder with the label
+        ``lookup_or_label`` will be unregistered.  If it is an function, the
+        decoder with the lookup function ``lookup_or_label`` will be
+        unregistered.
+        """
+        self._unregister(self._decoders, lookup_or_label)
+
+    def register(
+        self, lookup: Lookup, encoder: Encoder, decoder: Decoder, label: str = None
+    ) -> None:
+        """
+        Registers the given ``encoder`` and ``decoder`` under the given
+        ``lookup``.  A unique string label may be optionally provided that can
+        be used to refer to the registration by name.
+
+        :param lookup: A type string or type string matcher function
+            (predicate).  When the registry is queried with a type string
+            ``query`` to determine which encoder or decoder to use, ``query``
+            will be checked against every registration in the registry.  If a
+            registration was created with a type string for ``lookup``, it will
+            be considered a match if ``lookup == query``.  If a registration
+            was created with a matcher function for ``lookup``, it will be
+            considered a match if ``lookup(query) is True``.  If more than one
+            registration is found to be a match, then an exception is raised.
+
+        :param encoder: An encoder callable or class to use if ``lookup``
+            matches a query.  If ``encoder`` is a callable, it must accept a
+            python value and return a ``bytes`` value.  If ``encoder`` is a
+            class, it must be a valid subclass of :any:`encoding.BaseEncoder`
+            and must also implement the :any:`from_type_str` method on
+            :any:`base.BaseCoder`.
+
+        :param decoder: A decoder callable or class to use if ``lookup``
+            matches a query.  If ``decoder`` is a callable, it must accept a
+            stream-like object of bytes and return a python value.  If
+            ``decoder`` is a class, it must be a valid subclass of
+            :any:`decoding.BaseDecoder` and must also implement the
+            :any:`from_type_str` method on :any:`base.BaseCoder`.
+
+        :param label: An optional label that can be used to refer to this
+            registration by name.  This label can be used to unregister an
+            entry in the registry via the :any:`unregister` method and its
+            variants.
+        """
+        self.register_encoder(lookup, encoder, label=label)
+        self.register_decoder(lookup, decoder, label=label)
+
+    def unregister(self, label: str) -> None:
+        """
+        Unregisters the entries in the encoder and decoder registries which
+        have the label ``label``.
+        """
+        self.unregister_encoder(label)
+        self.unregister_decoder(label)
+
+    @functools.lru_cache(maxsize=None)
+    def get_encoder(self, type_str):
+        return self._get_registration(self._encoders, type_str)
+
+    def has_encoder(self, type_str: abi.TypeStr) -> bool:
+        """
+        Returns ``True`` if an encoder is found for the given type string
+        ``type_str``.  Otherwise, returns ``False``.  Raises
+        :class:`~eth_abi.exceptions.MultipleEntriesFound` if multiple encoders
+        are found.
+        """
+        try:
+            self.get_encoder(type_str)
+        except (ABITypeError, NoEntriesFound):
+            return False
+        else:
+            return True
+
+    @functools.lru_cache(maxsize=None)
+    def get_decoder(self, type_str):
+        return self._get_registration(self._decoders, type_str)
+
+    def copy(self):
+        """
+        Copies a registry such that new registrations can be made or existing
+        registrations can be unregistered without affecting any instance from
+        which a copy was obtained.  This is useful if an existing registry
+        fulfills most of a user's needs but requires one or two modifications.
+        In that case, a copy of that registry can be obtained and the necessary
+        changes made without affecting the original registry.
+        """
+        cpy = type(self)()
+
+        cpy._encoders = copy.copy(self._encoders)
+        cpy._decoders = copy.copy(self._decoders)
+
+        return cpy
+
+
+registry = ABIRegistry()
+
+registry.register(
+    BaseEquals("uint"),
+    encoding.UnsignedIntegerEncoder,
+    decoding.UnsignedIntegerDecoder,
+    label="uint",
+)
+registry.register(
+    BaseEquals("int"),
+    encoding.SignedIntegerEncoder,
+    decoding.SignedIntegerDecoder,
+    label="int",
+)
+registry.register(
+    BaseEquals("address"),
+    encoding.AddressEncoder,
+    decoding.AddressDecoder,
+    label="address",
+)
+registry.register(
+    BaseEquals("bool"),
+    encoding.BooleanEncoder,
+    decoding.BooleanDecoder,
+    label="bool",
+)
+registry.register(
+    BaseEquals("ufixed"),
+    encoding.UnsignedFixedEncoder,
+    decoding.UnsignedFixedDecoder,
+    label="ufixed",
+)
+registry.register(
+    BaseEquals("fixed"),
+    encoding.SignedFixedEncoder,
+    decoding.SignedFixedDecoder,
+    label="fixed",
+)
+registry.register(
+    BaseEquals("bytes", with_sub=True),
+    encoding.BytesEncoder,
+    decoding.BytesDecoder,
+    label="bytes<M>",
+)
+registry.register(
+    BaseEquals("bytes", with_sub=False),
+    encoding.ByteStringEncoder,
+    decoding.ByteStringDecoder,
+    label="bytes",
+)
+registry.register(
+    BaseEquals("function"),
+    encoding.BytesEncoder,
+    decoding.BytesDecoder,
+    label="function",
+)
+registry.register(
+    BaseEquals("string"),
+    encoding.TextStringEncoder,
+    decoding.StringDecoder,
+    label="string",
+)
+registry.register(
+    has_arrlist,
+    encoding.BaseArrayEncoder,
+    decoding.BaseArrayDecoder,
+    label="has_arrlist",
+)
+registry.register(
+    is_base_tuple,
+    encoding.TupleEncoder,
+    decoding.TupleDecoder,
+    label="is_base_tuple",
+)
+
+registry_packed = ABIRegistry()
+
+registry_packed.register_encoder(
+    BaseEquals("uint"),
+    encoding.PackedUnsignedIntegerEncoder,
+    label="uint",
+)
+registry_packed.register_encoder(
+    BaseEquals("int"),
+    encoding.PackedSignedIntegerEncoder,
+    label="int",
+)
+registry_packed.register_encoder(
+    BaseEquals("address"),
+    encoding.PackedAddressEncoder,
+    label="address",
+)
+registry_packed.register_encoder(
+    BaseEquals("bool"),
+    encoding.PackedBooleanEncoder,
+    label="bool",
+)
+registry_packed.register_encoder(
+    BaseEquals("ufixed"),
+    encoding.PackedUnsignedFixedEncoder,
+    label="ufixed",
+)
+registry_packed.register_encoder(
+    BaseEquals("fixed"),
+    encoding.PackedSignedFixedEncoder,
+    label="fixed",
+)
+registry_packed.register_encoder(
+    BaseEquals("bytes", with_sub=True),
+    encoding.PackedBytesEncoder,
+    label="bytes<M>",
+)
+registry_packed.register_encoder(
+    BaseEquals("bytes", with_sub=False),
+    encoding.PackedByteStringEncoder,
+    label="bytes",
+)
+registry_packed.register_encoder(
+    BaseEquals("function"),
+    encoding.PackedBytesEncoder,
+    label="function",
+)
+registry_packed.register_encoder(
+    BaseEquals("string"),
+    encoding.PackedTextStringEncoder,
+    label="string",
+)
+registry_packed.register_encoder(
+    has_arrlist,
+    encoding.PackedArrayEncoder,
+    label="has_arrlist",
+)
+registry_packed.register_encoder(
+    is_base_tuple,
+    encoding.TupleEncoder,
+    label="is_base_tuple",
+)

coinex/ccxt/static_dependencies/ethereum/abi/tools/__init__.py

@@ -0,0 +1,3 @@
+from ._strategies import (  # noqa: F401
+    get_abi_strategy,
+)