coinex-api 0.0.69__py3-none-any.whl → 0.0.70__py3-none-any.whl

coinex/ccxt/__init__.py

@@ -26,7 +26,7 @@ sys.modules['ccxt'] = ccxt_module
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.4.90'
+__version__ = '4.4.91'
 
 # ----------------------------------------------------------------------------
 

coinex/ccxt/async_support/__init__.py

@@ -8,7 +8,7 @@ sys.modules['ccxt'] = ccxt_module
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.4.90'
+__version__ = '4.4.91'
 
 # -----------------------------------------------------------------------------
 

coinex/ccxt/async_support/base/exchange.py

@@ -2,7 +2,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.4.90'
+__version__ = '4.4.91'
 
 # -----------------------------------------------------------------------------
 
@@ -34,7 +34,7 @@ from ccxt.base.exchange import Exchange as BaseExchange, ArgumentsRequired
 # -----------------------------------------------------------------------------
 
 from ccxt.async_support.base.ws.functions import inflate, inflate64, gunzip
-from ccxt.async_support.base.ws.aiohttp_client import AiohttpClient
+from ccxt.async_support.base.ws.client import Client
 from ccxt.async_support.base.ws.future import Future
 from ccxt.async_support.base.ws.order_book import OrderBook, IndexedOrderBook, CountedOrderBook
 
@@ -419,7 +419,7 @@ class Exchange(BaseExchange):
             }, ws_options)
             # we use aiohttp instead of fastClient now because of this
             # https://github.com/ccxt/ccxt/pull/25995
-            self.clients[url] = AiohttpClient(url, on_message, on_error, on_close, on_connected, options)
+            self.clients[url] = Client(url, on_message, on_error, on_close, on_connected, options)
             # set http/s proxy (socks proxy should be set in other place)
             httpProxy, httpsProxy, socksProxy = self.check_ws_proxy_settings()
             if (httpProxy or httpsProxy):
@@ -638,6 +638,9 @@ class Exchange(BaseExchange):
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}):
         raise NotSupported(self.id + ' watchTrades() is not supported yet')
 
+    async def un_watch_orders(self, symbol: Str = None, params={}):
+        raise NotSupported(self.id + ' unWatchOrders() is not supported yet')
+
     async def un_watch_trades(self, symbol: str, params={}):
         raise NotSupported(self.id + ' unWatchTrades() is not supported yet')
 

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

@@ -1,21 +1,31 @@
 # -*- 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
+orjson = None
+try:
+    import orjson as orjson
+except ImportError:
+    pass
+
+import json
+
+from asyncio import sleep, ensure_future, wait_for, TimeoutError, BaseEventLoop, Future as asyncioFuture
+from .functions import milliseconds, iso8601, deep_extend, is_json_encoded_object
+from ccxt import NetworkError, RequestTimeout
 from ccxt.async_support.base.ws.future import Future
-from collections import deque
+from ccxt.async_support.base.ws.functions import gunzip, inflate
+from typing import Dict
+
+from aiohttp import WSMsgType
+
 
 class Client(object):
 
     url = None
     ws = None
-    futures = {}
+    futures: Dict[str, Future] = {}
     options = {}  # ws-specific options
     subscriptions = {}
     rejections = {}
-    message_queue = {}
-    useMessageQueue = False
     on_message_callback = None
     on_error_callback = None
     on_close_callback = None
@@ -32,14 +42,14 @@ class Client(object):
     maxPingPongMisses = 2.0  # how many missed pongs to raise a timeout
     lastPong = None
     ping = None  # ping-function if defined
+    proxy = None
     verbose = False  # verbose output
     gunzip = False
     inflate = False
     throttle = None
     connecting = False
-    asyncio_loop = None
+    asyncio_loop: BaseEventLoop = 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 = {
@@ -70,37 +80,19 @@ class Client(object):
         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]
+        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 is not None:
             if message_hash in self.futures:
                 future = self.futures[message_hash]
                 future.reject(result)
@@ -113,19 +105,38 @@ class Client(object):
                 self.reject(result, message_hash)
         return result
 
-    async def receive_loop(self):
+    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)
+        if not self.closed():
+            # let's drain the aiohttp buffer to avoid latency
+            if len(self.buffer) > 1:
+                size_delta = 0
+                while len(self.buffer) > 1:
+                    message, size = self.buffer.popleft()
+                    size_delta += size
+                    self.handle_message(message)
+                # we must update the size of the last message inside WebSocketDataQueue
+                # self.receive() calls WebSocketDataQueue.read() that calls WebSocketDataQueue._read_from_buffer()
+                # which updates the size of the buffer, the _size will overflow and pause the transport
+                # make sure to set the enviroment variable AIOHTTP_NO_EXTENSIONS=Y to check
+                # print(self.connection._conn.protocol._payload._size)
+                self.buffer[0] = (self.buffer[0][0], self.buffer[0][1] + size_delta)
+
+            task = self.asyncio_loop.create_task(self.receive())
+
+            def after_interrupt(resolved: asyncioFuture):
+                exception = resolved.exception()
+                if exception is None:
+                    self.handle_message(resolved.result())
+                    self.asyncio_loop.call_soon(self.receive_loop)
+                else:
+                    error = NetworkError(str(exception))
+                    if self.verbose:
+                        self.log(iso8601(milliseconds()), 'receive_loop', 'Exception', error)
+                    self.reset(error)
+
+            task.add_done_callback(after_interrupt)
 
     async def open(self, session, backoff_delay=0):
         # exponential backoff for consequent connections if necessary
@@ -146,7 +157,7 @@ class Client(object):
             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)
+            self.asyncio_loop.call_soon(self.receive_loop)
         except TimeoutError:
             # connection timeout
             error = RequestTimeout('Connection timeout')
@@ -160,6 +171,13 @@ class Client(object):
                 self.log(iso8601(milliseconds()), 'NetworkError', error)
             self.on_error(error)
 
+    @property
+    def buffer(self):
+        # looks like they exposed it in C
+        # this means we can bypass it
+        # https://github.com/aio-libs/aiohttp/blob/master/aiohttp/_websocket/reader_c.pxd#L53C24-L53C31
+        return self.connection._conn.protocol._payload._buffer
+
     def connect(self, session, backoff_delay=0):
         if not self.connection and not self.connecting:
             self.connecting = True
@@ -170,7 +188,7 @@ class Client(object):
         if self.verbose:
             self.log(iso8601(milliseconds()), 'on_error', error)
         self.error = error
-        self.reset(error)
+        self.reject(error)
         self.on_error_callback(self, error)
         if not self.closed():
             ensure_future(self.close(1006), loop=self.asyncio_loop)
@@ -179,36 +197,127 @@ class Client(object):
         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.reject(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)
+        ensure_future(self.aiohttp_close(), loop=self.asyncio_loop)
 
-    def reset(self, error):
-        self.message_queue = {}
-        self.reject(error)
+    def log(self, *args):
+        print(*args)
 
-    async def ping_loop(self):
-        if self.verbose:
-            self.log(iso8601(milliseconds()), 'ping loop')
+    def closed(self):
+        return (self.connection is None) or self.connection.closed
 
     def receive(self):
-        raise NotSupported('receive() not implemented')
+        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):
-        raise NotSupported('handle_message() not implemented')
+        # 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.ERROR:
+            if self.verbose:
+                self.log(iso8601(milliseconds()), 'error', message)
+            error = NetworkError(str(message))
+            self.on_error(error)
 
-    def closed(self):
-        raise NotSupported('closed() not implemented')
+    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):
-        raise NotSupported('send() not implemented')
+        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):
-        raise NotSupported('close() not implemented')
+        if self.verbose:
+            self.log(iso8601(milliseconds()), 'closing', code)
+        for future in self.futures.values():
+            future.cancel()
+        await self.aiohttp_close()
 
-    def create_connection(self, session):
-        raise NotSupported('create_connection() not implemented')
+    async def aiohttp_close(self):
+        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()
 
-    def log(self, *args):
-        print(*args)
+    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/future.py

@@ -1,69 +1,42 @@
 import asyncio
-from ccxt import ExchangeClosedByUser
 
-class Future(asyncio.Future):
 
-    is_race_future = False
+class Future(asyncio.Future):
 
     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
+            self.set_result(result)
 
     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
+            self.set_exception(error)
 
     @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)
+            complete, _ = done.result()
+            # check for exceptions
+            exceptions = []
+            cancelled = False
+            for f in complete:
+                if f.cancelled():
+                    cancelled = True
+                else:
+                    err = f.exception()
+                    if err:
+                        exceptions.append(err)
+            # if any exceptions return with first exception
+            if len(exceptions) > 0:
+                future.set_exception(exceptions[0])
+            # else return first result
+            elif cancelled:
+                future.cancel()
+            else:
+                first_result = list(complete)[0].result()
+                future.set_result(first_result)
         task.add_done_callback(callback)
         return future

coinex/ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.4.90'
+__version__ = '4.4.91'
 
 # -----------------------------------------------------------------------------
 
@@ -2580,6 +2580,9 @@ class Exchange(object):
     def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}):
         raise NotSupported(self.id + ' watchTrades() is not supported yet')
 
+    def un_watch_orders(self, symbol: Str = None, params={}):
+        raise NotSupported(self.id + ' unWatchOrders() is not supported yet')
+
     def un_watch_trades(self, symbol: str, params={}):
         raise NotSupported(self.id + ' unWatchTrades() is not supported yet')
 
@@ -6894,7 +6897,7 @@ class Exchange(object):
                 symbolAndTimeFrame = symbolsAndTimeFrames[i]
                 symbol = self.safe_string(symbolAndTimeFrame, 0)
                 timeframe = self.safe_string(symbolAndTimeFrame, 1)
-                if symbol in self.ohlcvs:
+                if (self.ohlcvs is not None) and (symbol in self.ohlcvs):
                     if timeframe in self.ohlcvs[symbol]:
                         del self.ohlcvs[symbol][timeframe]
         elif symbolsLength > 0:
@@ -6910,7 +6913,7 @@ class Exchange(object):
                     if symbol in self.tickers:
                         del self.tickers[symbol]
         else:
-            if topic == 'myTrades':
+            if topic == 'myTrades' and (self.myTrades is not None):
                 # don't reset self.myTrades directly here
                 # because in c# we need to use a different object(thread-safe dict)
                 keys = list(self.myTrades.keys())
@@ -6918,13 +6921,13 @@ class Exchange(object):
                     key = keys[i]
                     if key in self.myTrades:
                         del self.myTrades[key]
-            elif topic == 'orders':
+            elif topic == 'orders' and (self.orders is not None):
                 orderSymbols = list(self.orders.keys())
                 for i in range(0, len(orderSymbols)):
                     orderSymbol = orderSymbols[i]
                     if orderSymbol in self.orders:
                         del self.orders[orderSymbol]
-            elif topic == 'ticker':
+            elif topic == 'ticker' and (self.tickers is not None):
                 tickerSymbols = list(self.tickers.keys())
                 for i in range(0, len(tickerSymbols)):
                     tickerSymbol = tickerSymbols[i]

coinex/ccxt/pro/__init__.py

@@ -8,7 +8,7 @@ sys.modules['ccxt'] = ccxt_module
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.4.90'
+__version__ = '4.4.91'
 
 # ----------------------------------------------------------------------------
 

{coinex_api-0.0.69.dist-info → coinex_api-0.0.70.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coinex-api
-Version: 0.0.69
+Version: 0.0.70
 Summary: coinex crypto exchange api client
 Project-URL: Homepage, https://github.com/ccxt/ccxt
 Project-URL: Issues, https://github.com/ccxt/ccxt

{coinex_api-0.0.69.dist-info → coinex_api-0.0.70.dist-info}/RECORD

@@ -1,27 +1,26 @@
 coinex/__init__.py,sha256=d633U2PpNFHvpDWLb3lItS0ObcBN0E2XgS5QkOEejI8,246
-coinex/ccxt/__init__.py,sha256=T_c8ubbO0URpgxghKteY6ZLaOaEsGrZpIwxDnXelYUw,6048
+coinex/ccxt/__init__.py,sha256=7pmttuHlwm2_RP5dguv9X0IuFggsxsNzr2m8EoC8nCs,6048
 coinex/ccxt/coinex.py,sha256=CoCBNE0SWXgXBurhdqcsMuMsj3TnYALKFUz-_gLz2XA,267281
 coinex/ccxt/abstract/coinex.py,sha256=4TRXtWgONqkm3eSL55Y5T7Q4QxJrnOTuhP0ugsKHAWo,34856
-coinex/ccxt/async_support/__init__.py,sha256=bzX_4j6m_CDvygCtjeR9PUktVz6--UYe5AJMDu0SE5I,4781
+coinex/ccxt/async_support/__init__.py,sha256=myEiUuL75tiub92DBGA-6boG8TfiwjKr8Cx4mqlj838,4781
 coinex/ccxt/async_support/coinex.py,sha256=lj_2qf1gnqmXbVf_pXBZddBFsHeVmh_N2JIxBHhmPwM,268569
 coinex/ccxt/async_support/base/__init__.py,sha256=aVYSsFi--b4InRs9zDN_wtCpj8odosAB726JdUHavrk,67
-coinex/ccxt/async_support/base/exchange.py,sha256=3qo41BpgIc0nGYI3Fka9-_Wodr_xbzh47eW0jAuMsUQ,119161
+coinex/ccxt/async_support/base/exchange.py,sha256=RBB3v5Eqi6U0twVnaocSBCk0MD87meBQdYIz_mGCRUs,119286
 coinex/ccxt/async_support/base/throttler.py,sha256=tvDVcdRUVYi8fZRlEcnqtgzcgB_KMUMRs5Pu8tuU-tU,1847
 coinex/ccxt/async_support/base/ws/__init__.py,sha256=uockzpLuwntKGZbs5EOWFe-Zg-k6Cj7GhNJLc_RX0so,1791
-coinex/ccxt/async_support/base/ws/aiohttp_client.py,sha256=Y5HxAVXyyYduj6b6SbbUZETlq3GrVMzrkW1r-TMgpb8,6329
 coinex/ccxt/async_support/base/ws/cache.py,sha256=xf2VOtfUwloxSlIQ39M1RGZHWQzyS9IGhB5NX6cDcAc,8370
-coinex/ccxt/async_support/base/ws/client.py,sha256=J5lTz3QGTaURZYeqW4R5xNw1orDlHYoOVXIJIX6d5Zc,8188
+coinex/ccxt/async_support/base/ws/client.py,sha256=3H6NnHk7GIC6wqJ49eshuvy5MnT3ma4cnAPSWKNy6S8,13475
 coinex/ccxt/async_support/base/ws/functions.py,sha256=qwvEnjtINWL5ZU-dbbeIunjyBxzFqbGWHfVhxqAcKug,1499
-coinex/ccxt/async_support/base/ws/future.py,sha256=WhAJ7wdEiLdfgl5tfGHv6HgLxAN0tTc9xL4gbkKVOaE,2409
+coinex/ccxt/async_support/base/ws/future.py,sha256=9yFyxqT7cl-7ZFM6LM4b6UPXyO2FGIbAhs5uoJ3-Smo,1271
 coinex/ccxt/async_support/base/ws/order_book.py,sha256=uBUaIHhzMRykpmo4BCsdJ-t_HozS6VxhEs8x-Kbj-NI,2894
 coinex/ccxt/async_support/base/ws/order_book_side.py,sha256=GhnGUt78pJ-AYL_Dq9produGjmBJLCI5FHIRdMz1O-g,6551
 coinex/ccxt/base/__init__.py,sha256=eTx1OE3HJjspFUQjGm6LBhaQiMKJnXjkdP-JUXknyQ0,1320
 coinex/ccxt/base/decimal_to_precision.py,sha256=fgWRBzRTtsf3r2INyS4f7WHlzgjB5YM1ekiwqD21aac,6634
 coinex/ccxt/base/errors.py,sha256=MvCrL_sAM3de616T6RE0PSxiF2xV6Qqz5b1y1ghidbk,4888
-coinex/ccxt/base/exchange.py,sha256=b6TLBQicsWseX5icZF9BC89wQfUaqN5IPBSEcNOq1SM,328431
+coinex/ccxt/base/exchange.py,sha256=wjO_dKXa2T3CqHP7jZtL7grD_tifCcNn_wew8PNCotc,328697
 coinex/ccxt/base/precise.py,sha256=koce64Yrp6vFbGijJtUt-QQ6XhJgeGTCksZ871FPp_A,8886
 coinex/ccxt/base/types.py,sha256=IbLO7Ni-plO36xlOdJQFqujSJBq0q9qll009ShZ0M_U,11468
-coinex/ccxt/pro/__init__.py,sha256=XsqfwQUcuIZcHsBnurz6OO6sjdH1cE5NEXVfJxwWMoA,4095
+coinex/ccxt/pro/__init__.py,sha256=uRQDrYnIHi3nuDyFBc1mTLrYjxRSMYdHkHaRQu1PSoc,4095
 coinex/ccxt/pro/coinex.py,sha256=aQ6Xa4ML0PTCgGleDJuhjqntspAREz6XxQwX9IcD6OY,56616
 coinex/ccxt/static_dependencies/README.md,sha256=3TCvhhn09_Cqf9BDDpao1V7EfKHDpQ6k9oWRsLFixpU,18
 coinex/ccxt/static_dependencies/__init__.py,sha256=tzFje8cloqmiIE6kola3EaYC0SnD1izWnri69hzHsSw,168
@@ -282,6 +281,6 @@ coinex/ccxt/static_dependencies/toolz/curried/exceptions.py,sha256=gKFOHDIayAWnX
 coinex/ccxt/static_dependencies/toolz/curried/operator.py,sha256=ML92mknkAwzBl2NCm-4werSUmJEtSHNY9NSzhseNM9s,525
 coinex/ccxt/static_dependencies/typing_inspect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 coinex/ccxt/static_dependencies/typing_inspect/typing_inspect.py,sha256=5gIWomLPfuDpgd3gX1GlnX0MuXM3VorR4j2W2qXORiQ,28269
-coinex_api-0.0.69.dist-info/METADATA,sha256=T_4RyLSLaFa_t3jio6YK4UxlERIb1zEzq9b1Tfdyi20,19969
-coinex_api-0.0.69.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-coinex_api-0.0.69.dist-info/RECORD,,
+coinex_api-0.0.70.dist-info/METADATA,sha256=jNbtpJEkmSP0HhL5t6JJ1tyBpWUmLtxuXmtuP5Jp5kQ,19969
+coinex_api-0.0.70.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+coinex_api-0.0.70.dist-info/RECORD,,

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

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