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

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

@@ -0,0 +1,97 @@
+"""A faster version of aiohttp's websocket client that uses select and other optimizations"""
+
+import asyncio
+import socket
+import collections
+from ccxt.async_support.base.ws.aiohttp_client import AiohttpClient
+from ccxt.base.errors import NetworkError
+
+
+class FastClient(AiohttpClient):
+    transport = None
+
+    def __init__(self, url, on_message_callback, on_error_callback, on_close_callback, on_connected_callback, config={}):
+        super(FastClient, self).__init__(url, on_message_callback, on_error_callback, on_close_callback, on_connected_callback, config)
+        # instead of using the deque in aiohttp we implement our own for speed
+        # https://github.com/aio-libs/aiohttp/blob/1d296d549050aa335ef542421b8b7dad788246d5/aiohttp/streams.py#L534
+        self.stack = collections.deque()
+        self.callback_scheduled = False
+
+    def receive_loop(self):
+        def handler():
+            if not self.stack:
+                self.callback_scheduled = False
+                return
+            message = self.stack.popleft()
+            try:
+                self.handle_message(message)
+            except Exception as error:
+                self.reject(error)
+            self.asyncio_loop.call_soon(handler)
+
+        def feed_data(message, size):
+            if not self.callback_scheduled:
+                self.callback_scheduled = True
+                self.asyncio_loop.call_soon(handler)
+            self.stack.append(message)
+
+        def feed_eof():
+            if self.connection._close_code == 1000:  # OK close
+                self.on_close(1000)
+            else:
+                self.on_error(NetworkError("Abnormal closure of client"))  # ABNORMAL_CLOSURE
+
+        def wrapper(func):
+            def parse_frame(buf):
+                while self.stack:
+                    self.handle_message(self.stack.popleft())
+                return func(buf)
+            return parse_frame
+
+        async def close(code=1000, message=b''):
+            # this is needed because our other wrappers break the closing process
+            # we also don't wait for a response to the close message to speed it up
+            # this code is adapted from aiohttp client_ws.py
+            _self = self.connection
+            if not _self._closed:
+                _self._cancel_heartbeat()
+                _self._closed = True
+                try:
+                    await _self._writer.close(code, message)
+                    _self._response.close()
+                    _self._close_code = 1000
+                except asyncio.CancelledError:
+                    _self._response.close()
+                    _self._close_code = 1006
+                    raise
+                except Exception as exc:
+                    _self._close_code = 1006
+                    _self._exception = exc
+            return True
+
+        connection = self.connection._conn
+        if connection.closed:
+            # connection got terminated after the connection was made and before the receive loop ran
+            self.on_close(1006)
+            return
+        self.transport = connection.transport
+        # increase the RCVBUF so that the tcp window size can be larger
+        sock = self.transport.get_extra_info('socket')
+        current_size = sock.getsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF)
+        # 2 mebibytes is a performance value
+        new_size = max(current_size, 2097152)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, new_size)
+
+        ws_reader = connection.protocol._payload_parser
+        ws_reader.parse_frame = wrapper(ws_reader.parse_frame)
+        ws_reader.queue.feed_data = feed_data
+        ws_reader.queue.feed_eof = feed_eof
+        self.connection.close = close
+        # return a future so super class won't complain
+        return asyncio.sleep(0)
+
+    def reset(self, error):
+        super(FastClient, self).reset(error)
+        self.stack.clear()
+        if self.transport:
+            self.transport.abort()

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

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+
+from zlib import decompress, MAX_WBITS
+from base64 import b64decode
+from gzip import GzipFile
+from io import BytesIO
+import time
+import datetime
+
+
+def inflate(data):
+    return decompress(data, -MAX_WBITS)
+
+
+def inflate64(data):
+    return inflate(b64decode(data))
+
+
+def gunzip(data):
+    return GzipFile('', 'rb', 9, BytesIO(data)).read().decode('utf-8')
+
+
+#  Tmp : added methods below to avoid circular imports between exchange.py and aiohttp.py
+
+def milliseconds():
+    return int(time.time() * 1000)
+
+
+def iso8601(timestamp=None):
+    if timestamp is None:
+        return timestamp
+    if not isinstance(timestamp, int):
+        return None
+    if int(timestamp) < 0:
+        return None
+    try:
+        utc = datetime.datetime.fromtimestamp(timestamp // 1000, datetime.timezone.utc)
+        return utc.strftime('%Y-%m-%dT%H:%M:%S.%f')[:-6] + "{:03d}".format(int(timestamp) % 1000) + 'Z'
+    except (TypeError, OverflowError, OSError):
+        return None
+
+
+def is_json_encoded_object(input):
+    return (isinstance(input, str) and
+            (len(input) >= 2) and
+            ((input[0] == '{') or (input[0] == '[')))
+
+
+def deep_extend(*args):
+    result = None
+    for arg in args:
+        if isinstance(arg, dict):
+            if not isinstance(result, dict):
+                result = {}
+            for key in arg:
+                result[key] = deep_extend(result[key] if key in result else None, arg[key])
+        else:
+            result = arg
+    return result

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

@@ -0,0 +1,69 @@
+import asyncio
+from ccxt import ExchangeClosedByUser
+
+class Future(asyncio.Future):
+
+    is_race_future = False
+
+    def resolve(self, result=None):
+        if not self.done():
+            try:
+                self.set_result(result)
+            except BaseException as e:
+                print("Error in Future.resolve")
+                raise e
+
+    def reject(self, error=None):
+        if not self.done():
+            # If not an exception, wrap it in a generic Exception
+            if not isinstance(error, BaseException):
+                error = Exception(error)
+            try:
+                self.set_exception(error)
+            except BaseException as e:
+                print("Error in Future.reject")
+                raise e
+
+    @classmethod
+    def race(cls, futures):
+        future = Future()
+        for f in futures:
+            f.is_race_future = True
+        coro = asyncio.wait(futures, return_when=asyncio.FIRST_COMPLETED)
+        task = asyncio.create_task(coro)
+
+        def callback(done):
+            try:
+                complete, pending = done.result()
+                # check for exceptions
+                for i, f in enumerate(complete):
+                    try:
+                        f.result()
+                    except ExchangeClosedByUser as e:
+                        if len(pending) == 0 and i == len(complete) - 1:
+                            future.reject(e)
+                        # wait for all the sub promises to be reject before rejecting future
+                        continue
+                    except asyncio.CancelledError as e:
+                        continue
+                    except Exception as e:
+                        future.reject(e)
+                        return
+                # no exceptions return first result
+                futures_list = list(complete)
+
+                are_all_canceled = all([f.cancelled() for f in futures_list])
+                if are_all_canceled:
+                    future.reject(ExchangeClosedByUser('Connection closed by the user'))
+                    return
+
+                first = futures_list[0]
+
+                first_result = first.result()
+                future.resolve(first_result)
+            except asyncio.CancelledError as e:
+                future.reject(e)
+            except Exception as e:
+                future.reject(e)
+        task.add_done_callback(callback)
+        return future

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

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+
+from ccxt.async_support.base.ws import order_book_side
+from ccxt import Exchange
+import sys
+
+
+class OrderBook(dict):
+    def __init__(self, snapshot={}, depth=None):
+        self.cache = []
+        depth = depth or sys.maxsize
+        defaults = {
+            'bids': [],
+            'asks': [],
+            'timestamp': None,
+            'datetime': None,
+            'nonce': None,
+            'symbol': None,
+        }
+        # do not mutate snapshot
+        defaults.update(snapshot)
+        if not isinstance(defaults['asks'], order_book_side.OrderBookSide):
+            defaults['asks'] = order_book_side.Asks(defaults['asks'], depth)
+        if not isinstance(defaults['bids'], order_book_side.OrderBookSide):
+            defaults['bids'] = order_book_side.Bids(defaults['bids'], depth)
+        defaults['datetime'] = Exchange.iso8601(defaults.get('timestamp'))
+        # merge to self
+        super(OrderBook, self).__init__(defaults)
+
+    def limit(self):
+        self['asks'].limit()
+        self['bids'].limit()
+        return self
+
+    def reset(self, snapshot={}):
+        self['asks']._index.clear()
+        self['asks'].clear()
+        for ask in snapshot.get('asks', []):
+            self['asks'].storeArray(ask)
+        self['bids']._index.clear()
+        self['bids'].clear()
+        for bid in snapshot.get('bids', []):
+            self['bids'].storeArray(bid)
+        self['nonce'] = snapshot.get('nonce')
+        self['timestamp'] = snapshot.get('timestamp')
+        self['datetime'] = Exchange.iso8601(self['timestamp'])
+        self['symbol'] = snapshot.get('symbol')
+
+    def update(self, snapshot):
+        nonce = snapshot.get('nonce')
+        if nonce is not None and self['nonce'] is not None and nonce < self['nonce']:
+            return self
+        self.reset(snapshot)
+
+# -----------------------------------------------------------------------------
+# overwrites absolute volumes at price levels
+# or deletes price levels based on order counts (3rd value in a bidask delta)
+
+
+class CountedOrderBook(OrderBook):
+    def __init__(self, snapshot={}, depth=None):
+        copy = Exchange.extend(snapshot, {
+            'asks': order_book_side.CountedAsks(snapshot.get('asks', []), depth),
+            'bids': order_book_side.CountedBids(snapshot.get('bids', []), depth),
+        })
+        super(CountedOrderBook, self).__init__(copy, depth)
+
+# -----------------------------------------------------------------------------
+# indexed by order ids (3rd value in a bidask delta)
+
+
+class IndexedOrderBook(OrderBook):
+    def __init__(self, snapshot={}, depth=None):
+        copy = Exchange.extend(snapshot, {
+            'asks': order_book_side.IndexedAsks(snapshot.get('asks', []), depth),
+            'bids': order_book_side.IndexedBids(snapshot.get('bids', []), depth),
+        })
+        super(IndexedOrderBook, self).__init__(copy, depth)

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

@@ -0,0 +1,174 @@
+# -*- coding: utf-8 -*-
+
+import sys
+import bisect
+
+"""Author: Carlo Revelli"""
+"""Fast bisect bindings"""
+"""https://github.com/python/cpython/blob/master/Modules/_bisectmodule.c"""
+"""Performs a binary search when inserting keys in sorted order"""
+
+
+class OrderBookSide(list):
+    side = None  # set to True for bids and False for asks
+
+    def __init__(self, deltas=[], depth=None):
+        super(OrderBookSide, self).__init__()
+        self._depth = depth or sys.maxsize
+        self._n = sys.maxsize
+        # parallel to self
+        self._index = []
+        for delta in deltas:
+            self.storeArray(list(delta))
+
+    def store_array(self, delta):
+        return self.storeArray(delta)
+
+    def storeArray(self, delta):
+        price = delta[0]
+        size = delta[1]
+        index_price = -price if self.side else price
+        index = bisect.bisect_left(self._index, index_price)
+        if size:
+            if index < len(self._index) and self._index[index] == index_price:
+                self[index][1] = size
+            else:
+                self._index.insert(index, index_price)
+                self.insert(index, delta)
+        elif index < len(self._index) and self._index[index] == index_price:
+            del self._index[index]
+            del self[index]
+
+    def store(self, price, size):
+        self.storeArray([price, size])
+
+    def limit(self):
+        difference = len(self) - self._depth
+        for _ in range(difference):
+            self.remove_index(self.pop())
+            self._index.pop()
+
+    def remove_index(self, order):
+        pass
+
+    def __len__(self):
+        length = super(OrderBookSide, self).__len__()
+        return min(length, self._n)
+
+    def __getitem__(self, item):
+        if isinstance(item, slice):
+            start, stop, step = item.indices(len(self))
+            return [self[i] for i in range(start, stop, step)]
+        else:
+            return super(OrderBookSide, self).__getitem__(item)
+
+    def __eq__(self, other):
+        if isinstance(other, list):
+            return list(self) == other
+        return super(OrderBookSide, self).__eq__(other)
+
+    def __repr__(self):
+        return str(list(self))
+
+# -----------------------------------------------------------------------------
+# overwrites absolute volumes at price levels
+# or deletes price levels based on order counts (3rd value in a bidask delta)
+# this class stores vector arrays of values indexed by price
+
+
+class CountedOrderBookSide(OrderBookSide):
+    def __init__(self, deltas=[], depth=None):
+        super(CountedOrderBookSide, self).__init__(deltas, depth)
+
+    def storeArray(self, delta):
+        price = delta[0]
+        size = delta[1]
+        count = delta[2]
+        index_price = -price if self.side else price
+        index = bisect.bisect_left(self._index, index_price)
+        if size and count:
+            if index < len(self._index) and self._index[index] == index_price:
+                self[index][1] = size
+                self[index][2] = count
+            else:
+                self._index.insert(index, index_price)
+                self.insert(index, delta)
+        elif index < len(self._index) and self._index[index] == index_price:
+            del self._index[index]
+            del self[index]
+
+    def store(self, price, size, count):
+        self.storeArray([price, size, count])
+
+# -----------------------------------------------------------------------------
+# indexed by order ids (3rd value in a bidask delta)
+
+
+class IndexedOrderBookSide(OrderBookSide):
+    def __init__(self, deltas=[], depth=None):
+        self._hashmap = {}
+        super(IndexedOrderBookSide, self).__init__(deltas, depth)
+
+    def storeArray(self, delta):
+        price = delta[0]
+        if price is not None:
+            index_price = -price if self.side else price
+        else:
+            index_price = None
+        size = delta[1]
+        order_id = delta[2]
+        if size:
+            if order_id in self._hashmap:
+                old_price = self._hashmap[order_id]
+                index_price = index_price or old_price
+                # in case the price is not defined
+                delta[0] = abs(index_price)
+                # matches if price is not defined or if price matches
+                if index_price == old_price:
+                    # just overwrite the old index
+                    index = bisect.bisect_left(self._index, index_price)
+                    while self[index][2] != order_id:
+                        index += 1
+                    self._index[index] = index_price
+                    self[index] = delta
+                    return
+                else:
+                    # remove old price level
+                    old_index = bisect.bisect_left(self._index, old_price)
+                    while self[old_index][2] != order_id:
+                        old_index += 1
+                    del self._index[old_index]
+                    del self[old_index]
+            # insert new price level
+            self._hashmap[order_id] = index_price
+            index = bisect.bisect_left(self._index, index_price)
+            while index < len (self._index) and self._index[index] == index_price and self[index][2] < order_id:
+                index += 1
+            self._index.insert(index, index_price)
+            self.insert(index, delta)
+        elif order_id in self._hashmap:
+            old_price = self._hashmap[order_id]
+            index = bisect.bisect_left(self._index, old_price)
+            while self[index][2] != order_id:
+                index += 1
+            del self._index[index]
+            del self[index]
+            del self._hashmap[order_id]
+
+    def remove_index(self, order):
+        order_id = order[2]
+        if order_id in self._hashmap:
+            del self._hashmap[order_id]
+
+    def store(self, price, size, order_id):
+        self.storeArray([price, size, order_id])
+
+# -----------------------------------------------------------------------------
+# a more elegant syntax is possible here, but native inheritance is portable
+
+class Asks(OrderBookSide): side = False                                     # noqa
+class Bids(OrderBookSide): side = True                                      # noqa
+class CountedAsks(CountedOrderBookSide): side = False                       # noqa
+class CountedBids(CountedOrderBookSide): side = True                        # noqa
+class IndexedAsks(IndexedOrderBookSide): side = False                       # noqa
+class IndexedBids(IndexedOrderBookSide): side = True                        # noqa