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

coinex/ccxt/async_support/base/throttler.py

@@ -0,0 +1,50 @@
+import asyncio
+import collections
+from time import time
+
+
+class Throttler:
+    def __init__(self, config, loop=None):
+        self.loop = loop
+        self.config = {
+            'refillRate': 1.0,
+            'delay': 0.001,
+            'cost': 1.0,
+            'tokens': 0,
+            'maxCapacity': 2000,
+            'capacity': 1.0,
+        }
+        self.config.update(config)
+        self.queue = collections.deque()
+        self.running = False
+
+    async def looper(self):
+        last_timestamp = time() * 1000
+        while self.running:
+            future, cost = self.queue[0]
+            cost = self.config['cost'] if cost is None else cost
+            if self.config['tokens'] >= 0:
+                self.config['tokens'] -= cost
+                if not future.done():
+                    future.set_result(None)
+                self.queue.popleft()
+                # context switch
+                await asyncio.sleep(0)
+                if len(self.queue) == 0:
+                    self.running = False
+            else:
+                await asyncio.sleep(self.config['delay'])
+                now = time() * 1000
+                elapsed = now - last_timestamp
+                last_timestamp = now
+                self.config['tokens'] = min(self.config['tokens'] + elapsed * self.config['refillRate'], self.config['capacity'])
+
+    def __call__(self, cost=None):
+        future = asyncio.Future()
+        if len(self.queue) > self.config['maxCapacity']:
+            raise RuntimeError('throttle queue is over maxCapacity (' + str(int(self.config['maxCapacity'])) + '), see https://github.com/ccxt/ccxt/issues/11645#issuecomment-1195695526')
+        self.queue.append((future, cost))
+        if not self.running:
+            self.running = True
+            asyncio.ensure_future(self.looper(), loop=self.loop)
+        return future

coinex/ccxt/async_support/base/ws/__init__.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+
+from ccxt.base import errors
+
+# -----------------------------------------------------------------------------
+
+from ccxt.base import decimal_to_precision
+
+from ccxt import BaseError                  # noqa: F401
+from ccxt import ExchangeError              # noqa: F401
+from ccxt import NotSupported               # noqa: F401
+from ccxt import AuthenticationError        # noqa: F401
+from ccxt import PermissionDenied           # noqa: F401
+from ccxt import AccountSuspended           # noqa: F401
+from ccxt import InvalidNonce               # noqa: F401
+from ccxt import InsufficientFunds          # noqa: F401
+from ccxt import InvalidOrder               # noqa: F401
+from ccxt import OrderNotFound              # noqa: F401
+from ccxt import OrderNotCached             # noqa: F401
+from ccxt import DuplicateOrderId           # noqa: F401
+from ccxt import CancelPending              # noqa: F401
+from ccxt import NetworkError               # noqa: F401
+from ccxt import DDoSProtection             # noqa: F401
+from ccxt import RateLimitExceeded          # noqa: F401
+from ccxt import RequestTimeout             # noqa: F401
+from ccxt import ExchangeNotAvailable       # noqa: F401
+from ccxt import OnMaintenance              # noqa: F401
+from ccxt import InvalidAddress             # noqa: F401
+from ccxt import AddressPending             # noqa: F401
+from ccxt import ArgumentsRequired          # noqa: F401
+from ccxt import BadRequest                 # noqa: F401
+from ccxt import BadResponse                # noqa: F401
+from ccxt import NullResponse               # noqa: F401
+from ccxt import OrderImmediatelyFillable   # noqa: F401
+from ccxt import OrderNotFillable           # noqa: F401
+
+
+__all__ = decimal_to_precision.__all__ + errors.__all__  # noqa: F405

coinex/ccxt/async_support/base/ws/aiohttp_client.py

@@ -0,0 +1,147 @@
+# -*- coding: utf-8 -*-
+
+orjson = None
+try:
+    import orjson as orjson
+except ImportError:
+    pass
+
+import json
+from asyncio import sleep, ensure_future
+from aiohttp import WSMsgType
+from .functions import milliseconds, iso8601, is_json_encoded_object
+from ccxt.async_support.base.ws.client import Client
+from ccxt.async_support.base.ws.functions import gunzip, inflate
+from ccxt import NetworkError, RequestTimeout, ExchangeClosedByUser
+
+
+class AiohttpClient(Client):
+
+    proxy = None
+
+    def closed(self):
+        return (self.connection is None) or self.connection.closed
+
+    def receive(self):
+        return self.connection.receive()
+
+    # helper method for binary and text messages
+    def handle_text_or_binary_message(self, data):
+        if self.verbose:
+            self.log(iso8601(milliseconds()), 'message', data)
+        if isinstance(data, bytes):
+            data = data.decode()
+        # decoded = json.loads(data) if is_json_encoded_object(data) else data
+        decode = None
+        if is_json_encoded_object(data):
+            if orjson is None:
+                decode = json.loads(data)
+            else:
+                decode = orjson.loads(data)
+        else:
+            decode = data
+        self.on_message_callback(self, decode)
+
+    def handle_message(self, message):
+        # self.log(iso8601(milliseconds()), message)
+        if message.type == WSMsgType.TEXT:
+            self.handle_text_or_binary_message(message.data)
+        elif message.type == WSMsgType.BINARY:
+            data = message.data
+            if self.gunzip:
+                data = gunzip(data)
+            elif self.inflate:
+                data = inflate(data)
+            self.handle_text_or_binary_message(data)
+        # autoping is responsible for automatically replying with pong
+        # to a ping incoming from a server, we have to disable autoping
+        # with aiohttp's websockets and respond with pong manually
+        # otherwise aiohttp's websockets client won't trigger WSMsgType.PONG
+        elif message.type == WSMsgType.PING:
+            if self.verbose:
+                self.log(iso8601(milliseconds()), 'ping', message)
+            ensure_future(self.connection.pong(message.data), loop=self.asyncio_loop)
+        elif message.type == WSMsgType.PONG:
+            self.lastPong = milliseconds()
+            if self.verbose:
+                self.log(iso8601(milliseconds()), 'pong', message)
+            pass
+        elif message.type == WSMsgType.CLOSE:
+            if self.verbose:
+                self.log(iso8601(milliseconds()), 'close', self.closed(), message)
+            self.on_close(message.data)
+        elif message.type == WSMsgType.CLOSED:
+            if self.verbose:
+                self.log(iso8601(milliseconds()), 'closed', self.closed(), message)
+            self.on_close(1000)
+        elif message.type == WSMsgType.ERROR:
+            if self.verbose:
+                self.log(iso8601(milliseconds()), 'error', message)
+            error = NetworkError(str(message))
+            self.on_error(error)
+
+    def create_connection(self, session):
+        # autoping is responsible for automatically replying with pong
+        # to a ping incoming from a server, we have to disable autoping
+        # with aiohttp's websockets and respond with pong manually
+        # otherwise aiohttp's websockets client won't trigger WSMsgType.PONG
+        # call aenter here to simulate async with otherwise we get the error "await not called with future"
+        # if connecting to a non-existent endpoint
+        if (self.proxy):
+            return session.ws_connect(self.url, autoping=False, autoclose=False, headers=self.options.get('headers'), proxy=self.proxy, max_msg_size=10485760).__aenter__()
+        return session.ws_connect(self.url, autoping=False, autoclose=False, headers=self.options.get('headers'), max_msg_size=10485760).__aenter__()
+
+    async def send(self, message):
+        if self.verbose:
+            self.log(iso8601(milliseconds()), 'sending', message)
+        send_msg = None
+        if isinstance(message, str):
+            send_msg = message
+        else:
+            if orjson is None:
+                send_msg = json.dumps(message, separators=(',', ':'))
+            else:
+                send_msg = orjson.dumps(message).decode('utf-8')
+        return await self.connection.send_str(send_msg)
+
+    async def close(self, code=1000):
+        if self.verbose:
+            self.log(iso8601(milliseconds()), 'closing', code)
+        if not self.closed():
+            await self.connection.close()
+        # these will end automatically once self.closed() = True
+        # so we don't need to cancel them
+        if self.ping_looper:
+            self.ping_looper.cancel()
+        if self.receive_looper:
+            self.receive_looper.cancel()  # cancel all pending futures stored in self.futures
+        for key in self.futures:
+            future = self.futures[key]
+            if not future.done():
+                if future.is_race_future:
+                    future.cancel()  # this is an "internal" future so we want to cancel it silently
+                else:
+                    future.reject(ExchangeClosedByUser('Connection closed by the user'))
+
+
+    async def ping_loop(self):
+        if self.verbose:
+            self.log(iso8601(milliseconds()), 'ping loop')
+        while self.keepAlive and not self.closed():
+            now = milliseconds()
+            self.lastPong = now if self.lastPong is None else self.lastPong
+            if (self.lastPong + self.keepAlive * self.maxPingPongMisses) < now:
+                self.on_error(RequestTimeout('Connection to ' + self.url + ' timed out due to a ping-pong keepalive missing on time'))
+            # the following ping-clause is not necessary with aiohttp's built-in ws
+            # since it has a heartbeat option (see create_connection above)
+            # however some exchanges require a text-type ping message
+            # therefore we need this clause anyway
+            else:
+                if self.ping:
+                    try:
+                        await self.send(self.ping(self))
+                    except Exception as e:
+                        self.on_error(e)
+                else:
+                    await self.connection.ping()
+            await sleep(self.keepAlive / 1000)

coinex/ccxt/async_support/base/ws/cache.py

@@ -0,0 +1,213 @@
+import collections
+
+
+class Delegate:
+    def __init__(self, name, delegated):
+        self.name = name
+        self.delegated = delegated
+
+    def __get__(self, instance, owner):
+        deque = getattr(instance, self.delegated)
+        return getattr(deque, self.name)
+
+
+class BaseCache(list):
+    # implicitly called magic methods don't invoke __getattribute__
+    # https://docs.python.org/3/reference/datamodel.html#special-method-lookup
+    # all method lookups obey the descriptor protocol
+    # this is how the implicit api is defined in ccxt
+    __iter__ = Delegate('__iter__', '_deque')
+    __setitem__ = Delegate('__setitem__', '_deque')
+    __delitem__ = Delegate('__delitem__', '_deque')
+    __len__ = Delegate('__len__', '_deque')
+    __contains__ = Delegate('__contains__', '_deque')
+    __reversed__ = Delegate('__reversed__', '_deque')
+    clear = Delegate('clear', '_deque')
+    pop = Delegate('pop', '_deque')
+
+    def __init__(self, max_size=None):
+        super(BaseCache, self).__init__()
+        self.max_size = max_size
+        self._deque = collections.deque([], max_size)
+
+    def __eq__(self, other):
+        return list(self) == other
+
+    def __repr__(self):
+        return str(list(self))
+
+    def __add__(self, other):
+        return list(self) + other
+
+    def __getitem__(self, item):
+        # deque doesn't support slicing
+        deque = super(list, self).__getattribute__('_deque')
+        if isinstance(item, slice):
+            start, stop, step = item.indices(len(deque))
+            return [deque[i] for i in range(start, stop, step)]
+        else:
+            return deque[item]
+
+    # to be overriden
+    def getLimit(self, symbol, limit):
+        pass
+
+    # support transpiled snake_case calls
+    def get_limit(self, symbol, limit):
+        return self.getLimit(symbol, limit)
+
+
+class ArrayCache(BaseCache):
+    def __init__(self, max_size=None):
+        super(ArrayCache, self).__init__(max_size)
+        self._nested_new_updates_by_symbol = False
+        self._new_updates_by_symbol = {}
+        self._clear_updates_by_symbol = {}
+        self._all_new_updates = 0
+        self._clear_all_updates = False
+
+    def getLimit(self, symbol, limit):
+        if symbol is None:
+            new_updates_value = self._all_new_updates
+            self._clear_all_updates = True
+        else:
+            new_updates_value = self._new_updates_by_symbol.get(symbol)
+            if new_updates_value is not None and self._nested_new_updates_by_symbol:
+                new_updates_value = len(new_updates_value)
+            self._clear_updates_by_symbol[symbol] = True
+
+        if new_updates_value is None:
+            return limit
+        elif limit is not None:
+            return min(new_updates_value, limit)
+        else:
+            return new_updates_value
+
+    def append(self, item):
+        self._deque.append(item)
+        if self._clear_all_updates:
+            self._clear_all_updates = False
+            self._clear_updates_by_symbol.clear()
+            self._all_new_updates = 0
+            self._new_updates_by_symbol.clear()
+        if self._clear_updates_by_symbol.get(item['symbol']):
+            self._clear_updates_by_symbol[item['symbol']] = False
+            self._new_updates_by_symbol[item['symbol']] = 0
+        self._new_updates_by_symbol[item['symbol']] = self._new_updates_by_symbol.get(item['symbol'], 0) + 1
+        self._all_new_updates = (self._all_new_updates or 0) + 1
+
+
+class ArrayCacheByTimestamp(BaseCache):
+    def __init__(self, max_size=None):
+        super(ArrayCacheByTimestamp, self).__init__(max_size)
+        self.hashmap = {}
+        self._size_tracker = set()
+        self._new_updates = 0
+        self._clear_updates = False
+
+    def getLimit(self, symbol, limit):
+        self._clear_updates = True
+        if limit is None:
+            return self._new_updates
+        return min(self._new_updates, limit)
+
+    def append(self, item):
+        if item[0] in self.hashmap:
+            reference = self.hashmap[item[0]]
+            if reference != item:
+                reference[0:len(item)] = item
+        else:
+            self.hashmap[item[0]] = item
+            if len(self._deque) == self._deque.maxlen:
+                delete_reference = self._deque.popleft()
+                del self.hashmap[delete_reference[0]]
+            self._deque.append(item)
+        if self._clear_updates:
+            self._clear_updates = False
+            self._size_tracker.clear()
+        self._size_tracker.add(item[0])
+        self._new_updates = len(self._size_tracker)
+
+
+class ArrayCacheBySymbolById(ArrayCache):
+    def __init__(self, max_size=None):
+        super(ArrayCacheBySymbolById, self).__init__(max_size)
+        self._nested_new_updates_by_symbol = True
+        self.hashmap = {}
+        self._index = collections.deque([], max_size)
+
+    def append(self, item):
+        by_id = self.hashmap.setdefault(item['symbol'], {})
+        if item['id'] in by_id:
+            reference = by_id[item['id']]
+            if reference != item:
+                reference.update(item)
+            item = reference
+            index = self._index.index(item['id'])
+            del self._deque[index]
+            del self._index[index]
+        else:
+            by_id[item['id']] = item
+        if len(self._deque) == self._deque.maxlen:
+            delete_item = self._deque.popleft()
+            self._index.popleft()
+            del self.hashmap[delete_item['symbol']][delete_item['id']]
+        self._deque.append(item)
+        self._index.append(item['id'])
+        if self._clear_all_updates:
+            self._clear_all_updates = False
+            self._clear_updates_by_symbol.clear()
+            self._all_new_updates = 0
+            self._new_updates_by_symbol.clear()
+        if item['symbol'] not in self._new_updates_by_symbol:
+            self._new_updates_by_symbol[item['symbol']] = set()
+        if self._clear_updates_by_symbol.get(item['symbol']):
+            self._clear_updates_by_symbol[item['symbol']] = False
+            self._new_updates_by_symbol[item['symbol']].clear()
+        id_set = self._new_updates_by_symbol[item['symbol']]
+        before_length = len(id_set)
+        id_set.add(item['id'])
+        after_length = len(id_set)
+        self._all_new_updates = (self._all_new_updates or 0) + (after_length - before_length)
+
+
+class ArrayCacheBySymbolBySide(ArrayCache):
+    def __init__(self, max_size=None):
+        super(ArrayCacheBySymbolBySide, self).__init__(max_size)
+        self._nested_new_updates_by_symbol = True
+        self.hashmap = {}
+        self._index = collections.deque([], max_size)
+
+    def append(self, item):
+        by_side = self.hashmap.setdefault(item['symbol'], {})
+        if item['side'] in by_side:
+            reference = by_side[item['side']]
+            if reference != item:
+                reference.update(item)
+            item = reference
+            index = self._index.index(item['symbol'] + item['side'])
+            del self._deque[index]
+            del self._index[index]
+        else:
+            by_side[item['side']] = item
+        if len(self._deque) == self._deque.maxlen:
+            delete_item = self._deque.popleft()
+            self._index.popleft()
+            del self.hashmap[delete_item['symbol']][delete_item['side']]
+        self._deque.append(item)
+        self._index.append(item['symbol'] + item['side'])
+        if self._clear_all_updates:
+            self._clear_all_updates = False
+            self._clear_updates_by_symbol.clear()
+            self._all_new_updates = 0
+            self._new_updates_by_symbol.clear()
+        if item['symbol'] not in self._new_updates_by_symbol:
+            self._new_updates_by_symbol[item['symbol']] = set()
+        if self._clear_updates_by_symbol.get(item['symbol']):
+            self._clear_updates_by_symbol[item['symbol']] = False
+            self._new_updates_by_symbol[item['symbol']].clear()
+        side_set = self._new_updates_by_symbol[item['symbol']]
+        before_length = len(side_set)
+        side_set.add(item['side'])
+        after_length = len(side_set)
+        self._all_new_updates = (self._all_new_updates or 0) + (after_length - before_length)

coinex/ccxt/async_support/base/ws/client.py

@@ -0,0 +1,214 @@
+# -*- coding: utf-8 -*-
+
+from asyncio import sleep, ensure_future, wait_for, TimeoutError
+from .functions import milliseconds, iso8601, deep_extend
+from ccxt import NetworkError, RequestTimeout, NotSupported
+from ccxt.async_support.base.ws.future import Future
+from collections import deque
+
+class Client(object):
+
+    url = None
+    ws = None
+    futures = {}
+    options = {}  # ws-specific options
+    subscriptions = {}
+    rejections = {}
+    message_queue = {}
+    useMessageQueue = False
+    on_message_callback = None
+    on_error_callback = None
+    on_close_callback = None
+    on_connected_callback = None
+    connectionStarted = None
+    connectionEstablished = None
+    isConnected = False
+    connectionTimeout = 10000  # ms, false to disable
+    connection = None
+    error = None  # low-level networking exception, if any
+    connected = None  # connection-related Future
+    keepAlive = 5000
+    heartbeat = True
+    maxPingPongMisses = 2.0  # how many missed pongs to raise a timeout
+    lastPong = None
+    ping = None  # ping-function if defined
+    verbose = False  # verbose output
+    gunzip = False
+    inflate = False
+    throttle = None
+    connecting = False
+    asyncio_loop = None
+    ping_looper = None
+    receive_looper = None
+
+    def __init__(self, url, on_message_callback, on_error_callback, on_close_callback, on_connected_callback, config={}):
+        defaults = {
+            'url': url,
+            'futures': {},
+            'subscriptions': {},
+            'rejections': {},
+            'on_message_callback': on_message_callback,
+            'on_error_callback': on_error_callback,
+            'on_close_callback': on_close_callback,
+            'on_connected_callback': on_connected_callback,
+        }
+        settings = {}
+        settings.update(defaults)
+        settings.update(config)
+        for key in settings:
+            if hasattr(self, key) and isinstance(getattr(self, key), dict):
+                setattr(self, key, deep_extend(getattr(self, key), settings[key]))
+            else:
+                setattr(self, key, settings[key])
+        # connection-related Future
+        self.connected = Future()
+
+    def future(self, message_hash):
+        if message_hash not in self.futures or self.futures[message_hash].cancelled():
+            self.futures[message_hash] = Future()
+        future = self.futures[message_hash]
+        if message_hash in self.rejections:
+            future.reject(self.rejections[message_hash])
+            del self.rejections[message_hash]
+            del self.message_queue[message_hash]
+            return future
+        if self.useMessageQueue and message_hash in self.message_queue:
+            queue = self.message_queue[message_hash]
+            if len(queue):
+                future.resolve(queue.popleft())
+                del self.futures[message_hash]
+        return future
+
+    def resolve(self, result, message_hash):
+        if self.verbose and message_hash is None:
+            self.log(iso8601(milliseconds()), 'resolve received None messageHash')
+
+        if self.useMessageQueue:
+            if message_hash not in self.message_queue:
+                self.message_queue[message_hash] = deque(maxlen=10)
+            queue = self.message_queue[message_hash]
+            queue.append(result)
+            if message_hash in self.futures:
+                future = self.futures[message_hash]
+                future.resolve(queue.popleft())
+                del self.futures[message_hash]
+        else:
+            if message_hash in self.futures:
+                future = self.futures[message_hash]
+                future.resolve(result)
+                del self.futures[message_hash]
+        return result
+
+    def reject(self, result, message_hash=None):
+        if message_hash:
+            if message_hash in self.futures:
+                future = self.futures[message_hash]
+                future.reject(result)
+                del self.futures[message_hash]
+            else:
+                self.rejections[message_hash] = result
+        else:
+            message_hashes = list(self.futures.keys())
+            for message_hash in message_hashes:
+                self.reject(result, message_hash)
+        return result
+
+    async def receive_loop(self):
+        if self.verbose:
+            self.log(iso8601(milliseconds()), 'receive loop')
+        while not self.closed():
+            try:
+                message = await self.receive()
+                # self.log(iso8601(milliseconds()), 'received', message)
+                self.handle_message(message)
+            except Exception as e:
+                error = NetworkError(str(e))
+                if self.verbose:
+                    self.log(iso8601(milliseconds()), 'receive_loop', 'Exception', error)
+                self.reset(error)
+
+    async def open(self, session, backoff_delay=0):
+        # exponential backoff for consequent connections if necessary
+        if backoff_delay:
+            await sleep(backoff_delay)
+        if self.verbose:
+            self.log(iso8601(milliseconds()), 'connecting to', self.url, 'with timeout', self.connectionTimeout, 'ms')
+        self.connectionStarted = milliseconds()
+        try:
+            coroutine = self.create_connection(session)
+            self.connection = await wait_for(coroutine, timeout=int(self.connectionTimeout / 1000))
+            self.connecting = False
+            self.connectionEstablished = milliseconds()
+            self.isConnected = True
+            if self.verbose:
+                self.log(iso8601(milliseconds()), 'connected')
+            self.connected.resolve(self.url)
+            self.on_connected_callback(self)
+            # run both loops forever
+            self.ping_looper = ensure_future(self.ping_loop(), loop=self.asyncio_loop)
+            self.receive_looper = ensure_future(self.receive_loop(), loop=self.asyncio_loop)
+        except TimeoutError:
+            # connection timeout
+            error = RequestTimeout('Connection timeout')
+            if self.verbose:
+                self.log(iso8601(milliseconds()), 'RequestTimeout', error)
+            self.on_error(error)
+        except Exception as e:
+            # connection failed or rejected (ConnectionRefusedError, ClientConnectorError)
+            error = NetworkError(e)
+            if self.verbose:
+                self.log(iso8601(milliseconds()), 'NetworkError', error)
+            self.on_error(error)
+
+    def connect(self, session, backoff_delay=0):
+        if not self.connection and not self.connecting:
+            self.connecting = True
+            ensure_future(self.open(session, backoff_delay), loop=self.asyncio_loop)
+        return self.connected
+
+    def on_error(self, error):
+        if self.verbose:
+            self.log(iso8601(milliseconds()), 'on_error', error)
+        self.error = error
+        self.reset(error)
+        self.on_error_callback(self, error)
+        if not self.closed():
+            ensure_future(self.close(1006), loop=self.asyncio_loop)
+
+    def on_close(self, code):
+        if self.verbose:
+            self.log(iso8601(milliseconds()), 'on_close', code)
+        if not self.error:
+            self.reset(NetworkError('Connection closed by remote server, closing code ' + str(code)))
+        self.on_close_callback(self, code)
+        if not self.closed():
+            ensure_future(self.close(code), loop=self.asyncio_loop)
+
+    def reset(self, error):
+        self.message_queue = {}
+        self.reject(error)
+
+    async def ping_loop(self):
+        if self.verbose:
+            self.log(iso8601(milliseconds()), 'ping loop')
+
+    def receive(self):
+        raise NotSupported('receive() not implemented')
+
+    def handle_message(self, message):
+        raise NotSupported('handle_message() not implemented')
+
+    def closed(self):
+        raise NotSupported('closed() not implemented')
+
+    async def send(self, message):
+        raise NotSupported('send() not implemented')
+
+    async def close(self, code=1000):
+        raise NotSupported('close() not implemented')
+
+    def create_connection(self, session):
+        raise NotSupported('create_connection() not implemented')
+
+    def log(self, *args):
+        print(*args)