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

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

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

@@ -1,59 +0,0 @@
-# -*- 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

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

@@ -1,78 +0,0 @@
-# -*- 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

@@ -1,174 +0,0 @@
-# -*- 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