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

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

@@ -1,188 +0,0 @@
-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

@@ -1,159 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

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