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

coinex/ccxt/static_dependencies/ethereum/utils/humanize.py

@@ -0,0 +1,188 @@
+from typing import (
+    Any,
+    Iterable,
+    Iterator,
+    Tuple,
+    Union,
+)
+from urllib import (
+    parse,
+)
+
+from ..typing import (
+    URI,
+    Hash32,
+)
+
+from .currency import (
+    denoms,
+    from_wei,
+)
+
+from .toolz import (
+    sliding_window,
+    take,
+)
+
+
+def humanize_seconds(seconds: Union[float, int]) -> str:
+    if int(seconds) == 0:
+        return "0s"
+
+    unit_values = _consume_leading_zero_units(_humanize_seconds(int(seconds)))
+
+    return "".join((f"{amount}{unit}" for amount, unit in take(3, unit_values)))
+
+
+SECOND = 1
+MINUTE = 60
+HOUR = 60 * 60
+DAY = 24 * HOUR
+YEAR = 365 * DAY
+MONTH = YEAR // 12
+WEEK = 7 * DAY
+
+
+UNITS = (
+    (YEAR, "y"),
+    (MONTH, "m"),
+    (WEEK, "w"),
+    (DAY, "d"),
+    (HOUR, "h"),
+    (MINUTE, "m"),
+    (SECOND, "s"),
+)
+
+
+def _consume_leading_zero_units(
+    units_iter: Iterator[Tuple[int, str]]
+) -> Iterator[Tuple[int, str]]:
+    for amount, unit in units_iter:
+        if amount == 0:
+            continue
+        else:
+            yield (amount, unit)
+            break
+
+    yield from units_iter
+
+
+def _humanize_seconds(seconds: int) -> Iterator[Tuple[int, str]]:
+    remainder = seconds
+
+    for duration, unit in UNITS:
+        if not remainder:
+            break
+
+        num = remainder // duration
+        yield num, unit
+
+        remainder %= duration
+
+
+DISPLAY_HASH_CHARS = 4
+
+
+def humanize_bytes(value: bytes) -> str:
+    if len(value) <= DISPLAY_HASH_CHARS + 1:
+        return value.hex()
+    value_as_hex = value.hex()
+    head = value_as_hex[:DISPLAY_HASH_CHARS]
+    tail = value_as_hex[-1 * DISPLAY_HASH_CHARS :]
+    return f"{head}..{tail}"
+
+
+def humanize_hash(value: Hash32) -> str:
+    return humanize_bytes(value)
+
+
+def humanize_ipfs_uri(uri: URI) -> str:
+    if not is_ipfs_uri(uri):
+        raise TypeError(
+            f"{uri} does not look like a valid IPFS uri. Currently, "
+            "only CIDv0 hash schemes are supported."
+        )
+
+    parsed = parse.urlparse(uri)
+    ipfs_hash = parsed.netloc
+    head = ipfs_hash[:DISPLAY_HASH_CHARS]
+    tail = ipfs_hash[-1 * DISPLAY_HASH_CHARS :]
+    return f"ipfs://{head}..{tail}"
+
+
+def is_ipfs_uri(value: Any) -> bool:
+    if not isinstance(value, str):
+        return False
+
+    parsed = parse.urlparse(value)
+    if parsed.scheme != "ipfs" or not parsed.netloc:
+        return False
+
+    return _is_CIDv0_ipfs_hash(parsed.netloc)
+
+
+def _is_CIDv0_ipfs_hash(ipfs_hash: str) -> bool:
+    if ipfs_hash.startswith("Qm") and len(ipfs_hash) == 46:
+        return True
+    return False
+
+
+def _find_breakpoints(*values: int) -> Iterator[int]:
+    yield 0
+    for index, (left, right) in enumerate(sliding_window(2, values), 1):
+        if left + 1 == right:
+            continue
+        else:
+            yield index
+    yield len(values)
+
+
+def _extract_integer_ranges(*values: int) -> Iterator[Tuple[int, int]]:
+    """
+    Return a tuple of consecutive ranges of integers.
+
+    :param values: a sequence of ordered integers
+
+    - fn(1, 2, 3) -> ((1, 3),)
+    - fn(1, 2, 3, 7, 8, 9) -> ((1, 3), (7, 9))
+    - fn(1, 7, 8, 9) -> ((1, 1), (7, 9))
+    """
+    for left, right in sliding_window(2, _find_breakpoints(*values)):
+        chunk = values[left:right]
+        yield chunk[0], chunk[-1]
+
+
+def _humanize_range(bounds: Tuple[int, int]) -> str:
+    left, right = bounds
+    if left == right:
+        return str(left)
+    else:
+        return f"{left}-{right}"
+
+
+def humanize_integer_sequence(values_iter: Iterable[int]) -> str:
+    """
+    Return a concise, human-readable string representing a sequence of integers.
+
+    - fn((1, 2, 3)) -> '1-3'
+    - fn((1, 2, 3, 7, 8, 9)) -> '1-3|7-9'
+    - fn((1, 2, 3, 5, 7, 8, 9)) -> '1-3|5|7-9'
+    - fn((1, 7, 8, 9)) -> '1|7-9'
+    """
+    values = tuple(values_iter)
+    if not values:
+        return "(empty)"
+    else:
+        return "|".join(map(_humanize_range, _extract_integer_ranges(*values)))
+
+
+def humanize_wei(number: int) -> str:
+    if number >= denoms.finney:
+        unit = "ether"
+    elif number >= denoms.mwei:
+        unit = "gwei"
+    else:
+        unit = "wei"
+    amount = from_wei(number, unit)
+    x = f"{str(amount)} {unit}"
+    return x

coinex/ccxt/static_dependencies/ethereum/utils/logging.py

@@ -0,0 +1,159 @@
+import contextlib
+from functools import (
+    cached_property,
+)
+import logging
+from typing import (
+    Any,
+    Dict,
+    Iterator,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+)
+
+from .toolz import (
+    assoc,
+)
+
+DEBUG2_LEVEL_NUM = 8
+
+TLogger = TypeVar("TLogger", bound=logging.Logger)
+
+
+class ExtendedDebugLogger(logging.Logger):
+    """
+    Logging class that can be used for lower level debug logging.
+    """
+
+    @cached_property
+    def show_debug2(self) -> bool:
+        return self.isEnabledFor(DEBUG2_LEVEL_NUM)
+
+    def debug2(self, message: str, *args: Any, **kwargs: Any) -> None:
+        if self.show_debug2:
+            self.log(DEBUG2_LEVEL_NUM, message, *args, **kwargs)
+        else:
+            # When we find that `DEBUG2` isn't enabled we completely replace
+            # the `debug2` function in this instance of the logger with a noop
+            # lambda to further speed up
+            self.__dict__["debug2"] = lambda message, *args, **kwargs: None
+
+    def __reduce__(self) -> Tuple[Any, ...]:
+        # This is needed because our parent's implementation could
+        # cause us to become a regular Logger on unpickling.
+        return get_extended_debug_logger, (self.name,)
+
+
+def setup_DEBUG2_logging() -> None:
+    """
+    Installs the `DEBUG2` level logging levels to the main logging module.
+    """
+    if not hasattr(logging, "DEBUG2"):
+        logging.addLevelName(DEBUG2_LEVEL_NUM, "DEBUG2")
+        logging.DEBUG2 = DEBUG2_LEVEL_NUM  # type: ignore
+
+
+@contextlib.contextmanager
+def _use_logger_class(logger_class: Type[logging.Logger]) -> Iterator[None]:
+    original_logger_class = logging.getLoggerClass()
+    logging.setLoggerClass(logger_class)
+    try:
+        yield
+    finally:
+        logging.setLoggerClass(original_logger_class)
+
+
+def get_logger(name: str, logger_class: Union[Type[TLogger], None] = None) -> TLogger:
+    if logger_class is None:
+        return cast(TLogger, logging.getLogger(name))
+    else:
+        with _use_logger_class(logger_class):
+            # The logging module caches logger instances. The following code
+            # ensures that if there is a cached instance that we don't
+            # accidentally return the incorrect logger type because the logging
+            # module does not *update* the cached instance in the event that
+            # the global logging class changes.
+            #
+            # types ignored b/c mypy doesn't identify presence of
+            # manager on logging.Logger
+            manager = logging.Logger.manager
+            if name in manager.loggerDict:
+                if type(manager.loggerDict[name]) is not logger_class:
+                    del manager.loggerDict[name]
+            return cast(TLogger, logging.getLogger(name))
+
+
+def get_extended_debug_logger(name: str) -> ExtendedDebugLogger:
+    return get_logger(name, ExtendedDebugLogger)
+
+
+THasLoggerMeta = TypeVar("THasLoggerMeta", bound="HasLoggerMeta")
+
+
+class HasLoggerMeta(type):
+    """
+    Assigns a logger instance to a class, derived from the import path and name.
+
+    This metaclass uses `__qualname__` to identify a unique and meaningful name
+    to use when creating the associated logger for a given class.
+    """
+
+    logger_class = logging.Logger
+
+    def __new__(
+        mcls: Type[THasLoggerMeta],
+        name: str,
+        bases: Tuple[Type[Any]],
+        namespace: Dict[str, Any],
+    ) -> THasLoggerMeta:
+        if "logger" in namespace:
+            # If a logger was explicitly declared we shouldn't do anything to
+            # replace it.
+            return super().__new__(mcls, name, bases, namespace)
+        if "__qualname__" not in namespace:
+            raise AttributeError("Missing __qualname__")
+
+        with _use_logger_class(mcls.logger_class):
+            logger = logging.getLogger(namespace["__qualname__"])
+
+        return super().__new__(mcls, name, bases, assoc(namespace, "logger", logger))
+
+    @classmethod
+    def replace_logger_class(
+        mcls: Type[THasLoggerMeta], value: Type[logging.Logger]
+    ) -> Type[THasLoggerMeta]:
+        return type(mcls.__name__, (mcls,), {"logger_class": value})
+
+    @classmethod
+    def meta_compat(
+        mcls: Type[THasLoggerMeta], other: Type[type]
+    ) -> Type[THasLoggerMeta]:
+        return type(mcls.__name__, (mcls, other), {})
+
+
+class _BaseHasLogger(metaclass=HasLoggerMeta):
+    # This class exists to a allow us to define the type of the logger. Once
+    # python3.5 is deprecated this can be removed in favor of a simple type
+    # annotation on the main class.
+    logger = logging.Logger("")  # type: logging.Logger
+
+
+class HasLogger(_BaseHasLogger):
+    pass
+
+
+HasExtendedDebugLoggerMeta = HasLoggerMeta.replace_logger_class(ExtendedDebugLogger)
+
+
+class _BaseHasExtendedDebugLogger(metaclass=HasExtendedDebugLoggerMeta):  # type: ignore
+    # This class exists to a allow us to define the type of the logger. Once
+    # python3.5 is deprecated this can be removed in favor of a simple type
+    # annotation on the main class.
+    logger = ExtendedDebugLogger("")  # type: ExtendedDebugLogger
+
+
+class HasExtendedDebugLogger(_BaseHasExtendedDebugLogger):
+    pass

coinex/ccxt/static_dependencies/ethereum/utils/module_loading.py

@@ -0,0 +1,31 @@
+from importlib import (
+    import_module,
+)
+from typing import (
+    Any,
+)
+
+
+def import_string(dotted_path: str) -> Any:
+    """
+    Import a variable using its path and name.
+
+    :param dotted_path: dotted module path and variable/class name
+    :return: the attribute/class designated by the last name in the path
+    :raise: ImportError, if the import failed
+
+    Source: django.utils.module_loading
+    """
+    try:
+        module_path, class_name = dotted_path.rsplit(".", 1)
+    except ValueError:
+        msg = f"{dotted_path} doesn't look like a module path"
+        raise ImportError(msg)
+
+    module = import_module(module_path)
+
+    try:
+        return getattr(module, class_name)
+    except AttributeError:
+        msg = f'Module "{module_path}" does not define a "{class_name}" attribute/class'
+        raise ImportError(msg)

coinex/ccxt/static_dependencies/ethereum/utils/numeric.py

@@ -0,0 +1,43 @@
+from abc import (
+    ABC,
+    abstractmethod,
+)
+import decimal
+import numbers
+from typing import (
+    Any,
+    TypeVar,
+    Union,
+)
+
+
+class Comparable(ABC):
+    @abstractmethod
+    def __lt__(self, other: Any) -> bool:
+        ...
+
+    @abstractmethod
+    def __gt__(self, other: Any) -> bool:
+        ...
+
+
+TComparable = Union[Comparable, numbers.Real, int, float, decimal.Decimal]
+
+
+TValue = TypeVar("TValue", bound=TComparable)
+
+
+def clamp(lower_bound: TValue, upper_bound: TValue, value: TValue) -> TValue:
+    # The `mypy` ignore statements here are due to doing a comparison of
+    # `Union` types which isn't allowed. (per cburgdorf). This approach was
+    # chosen over using `typing.overload` to define multiple signatures for
+    # each comparison type here since the added value of "proper" typing
+    # doesn't seem to justify the complexity of having a bunch of different
+    # signatures defined. The external library perspective on this function
+    # should still be adequate under this approach
+    if value < lower_bound:  # type: ignore
+        return lower_bound
+    elif value > upper_bound:  # type: ignore
+        return upper_bound
+    else:
+        return value

coinex/ccxt/static_dependencies/ethereum/utils/toolz.py

@@ -0,0 +1,76 @@
+from ...toolz import (  # noqa: F401
+    accumulate,
+    assoc,
+    assoc_in,
+    comp,
+    complement,
+    compose,
+    concat,
+    concatv,
+    cons,
+    count,
+    countby,
+    curried,
+    curry,
+    dicttoolz,
+    diff,
+    dissoc,
+    do,
+    drop,
+    excepts,
+    filter,
+    first,
+    flip,
+    frequencies,
+    functoolz,
+    get,
+    get_in,
+    groupby,
+    identity,
+    interleave,
+    interpose,
+    isdistinct,
+    isiterable,
+    itemfilter,
+    itemmap,
+    iterate,
+    itertoolz,
+    join,
+    juxt,
+    keyfilter,
+    keymap,
+    last,
+    map,
+    mapcat,
+    memoize,
+    merge,
+    merge_sorted,
+    merge_with,
+    nth,
+    partial,
+    partition,
+    partition_all,
+    partitionby,
+    peek,
+    pipe,
+    pluck,
+    random_sample,
+    recipes,
+    reduce,
+    reduceby,
+    remove,
+    second,
+    sliding_window,
+    sorted,
+    tail,
+    take,
+    take_nth,
+    thread_first,
+    thread_last,
+    topk,
+    unique,
+    update_in,
+    utils,
+    valfilter,
+    valmap,
+)

coinex/ccxt/static_dependencies/ethereum/utils/types.py

@@ -0,0 +1,54 @@
+import collections.abc
+import numbers
+from typing import (
+    Any,
+)
+
+bytes_types = (bytes, bytearray)
+integer_types = (int,)
+text_types = (str,)
+string_types = (bytes, str, bytearray)
+
+
+def is_integer(value: Any) -> bool:
+    return isinstance(value, integer_types) and not isinstance(value, bool)
+
+
+def is_bytes(value: Any) -> bool:
+    return isinstance(value, bytes_types)
+
+
+def is_text(value: Any) -> bool:
+    return isinstance(value, text_types)
+
+
+def is_string(value: Any) -> bool:
+    return isinstance(value, string_types)
+
+
+def is_boolean(value: Any) -> bool:
+    return isinstance(value, bool)
+
+
+def is_dict(obj: Any) -> bool:
+    return isinstance(obj, collections.abc.Mapping)
+
+
+def is_list_like(obj: Any) -> bool:
+    return not is_string(obj) and isinstance(obj, collections.abc.Sequence)
+
+
+def is_list(obj: Any) -> bool:
+    return isinstance(obj, list)
+
+
+def is_tuple(obj: Any) -> bool:
+    return isinstance(obj, tuple)
+
+
+def is_null(obj: Any) -> bool:
+    return obj is None
+
+
+def is_number(obj: Any) -> bool:
+    return isinstance(obj, numbers.Number)

coinex/ccxt/static_dependencies/ethereum/utils/typing/__init__.py

@@ -0,0 +1,18 @@
+import warnings
+
+from .misc import (
+    Address,
+    AnyAddress,
+    ChecksumAddress,
+    HexAddress,
+    HexStr,
+    Primitives,
+    T,
+)
+
+warnings.warn(
+    "The eth_utils.typing module will be deprecated in favor "
+    "of eth-typing in the next major version bump.",
+    category=DeprecationWarning,
+    stacklevel=2,
+)

coinex/ccxt/static_dependencies/ethereum/utils/typing/misc.py

@@ -0,0 +1,14 @@
+from typing import (
+    TypeVar,
+)
+
+from ...typing import (  # noqa: F401
+    Address,
+    AnyAddress,
+    ChecksumAddress,
+    HexAddress,
+    HexStr,
+    Primitives,
+)
+
+T = TypeVar("T")

coinex/ccxt/static_dependencies/ethereum/utils/units.py

@@ -0,0 +1,31 @@
+import decimal
+
+# Units are in their own module here, so that they can keep this
+# formatting, as this module is excluded from black in pyproject.toml
+# fmt: off
+units = {
+    'wei':          decimal.Decimal('1'),  # noqa: E241
+    'kwei':         decimal.Decimal('1000'),  # noqa: E241
+    'babbage':      decimal.Decimal('1000'),  # noqa: E241
+    'femtoether':   decimal.Decimal('1000'),  # noqa: E241
+    'mwei':         decimal.Decimal('1000000'),  # noqa: E241
+    'lovelace':     decimal.Decimal('1000000'),  # noqa: E241
+    'picoether':    decimal.Decimal('1000000'),  # noqa: E241
+    'gwei':         decimal.Decimal('1000000000'),  # noqa: E241
+    'shannon':      decimal.Decimal('1000000000'),  # noqa: E241
+    'nanoether':    decimal.Decimal('1000000000'),  # noqa: E241
+    'nano':         decimal.Decimal('1000000000'),  # noqa: E241
+    'szabo':        decimal.Decimal('1000000000000'),  # noqa: E241
+    'microether':   decimal.Decimal('1000000000000'),  # noqa: E241
+    'micro':        decimal.Decimal('1000000000000'),  # noqa: E241
+    'finney':       decimal.Decimal('1000000000000000'),  # noqa: E241
+    'milliether':   decimal.Decimal('1000000000000000'),  # noqa: E241
+    'milli':        decimal.Decimal('1000000000000000'),  # noqa: E241
+    'ether':        decimal.Decimal('1000000000000000000'),  # noqa: E241
+    'kether':       decimal.Decimal('1000000000000000000000'),  # noqa: E241
+    'grand':        decimal.Decimal('1000000000000000000000'),  # noqa: E241
+    'mether':       decimal.Decimal('1000000000000000000000000'),  # noqa: E241
+    'gether':       decimal.Decimal('1000000000000000000000000000'),  # noqa: E241
+    'tether':       decimal.Decimal('1000000000000000000000000000000'),  # noqa: E241
+}
+# fmt: on

coinex/ccxt/static_dependencies/keccak/__init__.py

@@ -0,0 +1,3 @@
+from .keccak import SHA3
+
+__all__ = ['SHA3']