ccxt 4.2.77__py2.py3-none-any.whl → 4.4.48__py2.py3-none-any.whl

ccxt/async_support/base/ws/aiohttp_client.py

@@ -1,5 +1,11 @@
 # -*- 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
@@ -25,8 +31,16 @@ class AiohttpClient(Client):
             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
-        self.on_message_callback(self, decoded)
+        # 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)
@@ -74,13 +88,21 @@ class AiohttpClient(Client):
         # 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).__aenter__()
-        return session.ws_connect(self.url, autoping=False, autoclose=False, headers=self.options.get('headers')).__aenter__()
+            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)
-        return await self.connection.send_str(message if isinstance(message, str) else json.dumps(message, separators=(',', ':')))
+        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:
@@ -101,6 +123,7 @@ class AiohttpClient(Client):
                 else:
                     future.reject(ExchangeClosedByUser('Connection closed by the user'))
 
+
     async def ping_loop(self):
         if self.verbose:
             self.log(iso8601(milliseconds()), 'ping loop')

ccxt/async_support/base/ws/cache.py

@@ -23,6 +23,7 @@ class BaseCache(list):
     __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__()
@@ -184,7 +185,7 @@ class ArrayCacheBySymbolBySide(ArrayCache):
             if reference != item:
                 reference.update(item)
             item = reference
-            index = self._index.index(item['side'])
+            index = self._index.index(item['symbol'] + item['side'])
             del self._deque[index]
             del self._index[index]
         else:
@@ -194,7 +195,7 @@ class ArrayCacheBySymbolBySide(ArrayCache):
             self._index.popleft()
             del self.hashmap[delete_item['symbol']][delete_item['side']]
         self._deque.append(item)
-        self._index.append(item['side'])
+        self._index.append(item['symbol'] + item['side'])
         if self._clear_all_updates:
             self._clear_all_updates = False
             self._clear_updates_by_symbol.clear()

ccxt/async_support/base/ws/client.py

@@ -4,7 +4,7 @@ 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):
 
@@ -14,6 +14,8 @@ class Client(object):
     options = {}  # ws-specific options
     subscriptions = {}
     rejections = {}
+    message_queue = {}
+    useMessageQueue = False
     on_message_callback = None
     on_error_callback = None
     on_close_callback = None
@@ -68,15 +70,33 @@ 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 message_hash in self.futures:
-            future = self.futures[message_hash]
-            future.resolve(result)
-            del self.futures[message_hash]
+
+        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):
@@ -165,6 +185,7 @@ class Client(object):
             ensure_future(self.close(code), loop=self.asyncio_loop)
 
     def reset(self, error):
+        self.message_queue = {}
         self.reject(error)
 
     async def ping_loop(self):

ccxt/async_support/base/ws/fast_client.py

@@ -4,6 +4,7 @@ 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):
@@ -35,10 +36,10 @@ class FastClient(AiohttpClient):
             self.stack.append(message)
 
         def feed_eof():
-            if self._close_code == 1000:  # OK close
+            if self.connection._close_code == 1000:  # OK close
                 self.on_close(1000)
             else:
-                self.on_error(1006)  # ABNORMAL_CLOSURE
+                self.on_error(NetworkError("Abnormal closure of client"))  # ABNORMAL_CLOSURE
 
         def wrapper(func):
             def parse_frame(buf):
@@ -58,7 +59,7 @@ class FastClient(AiohttpClient):
                 try:
                     await _self._writer.close(code, message)
                     _self._response.close()
-                    self._close_code = 1000
+                    _self._close_code = 1000
                 except asyncio.CancelledError:
                     _self._response.close()
                     _self._close_code = 1006

ccxt/async_support/base/ws/functions.py

@@ -34,7 +34,7 @@ def iso8601(timestamp=None):
     if int(timestamp) < 0:
         return None
     try:
-        utc = datetime.datetime.utcfromtimestamp(timestamp // 1000)
+        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

ccxt/async_support/base/ws/future.py

@@ -1,18 +1,28 @@
 import asyncio
 from ccxt import ExchangeClosedByUser
 
-
 class Future(asyncio.Future):
 
     is_race_future = False
 
     def resolve(self, result=None):
         if not self.done():
-            self.set_result(result)
+            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():
-            self.set_exception(error)
+            # 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):
@@ -23,38 +33,37 @@ class Future(asyncio.Future):
         task = asyncio.create_task(coro)
 
         def callback(done):
-            exception = done.exception()
-            if exception is None:
-                complete, _ = done.result()
+            try:
+                complete, pending = done.result()
                 # check for exceptions
-                exceptions = []
-                for f in complete:
-                    if f._state == 'CANCELLED':
-                        continue  # was canceled internally
-                    err = f.exception()
-                    if err:
-                        exceptions.append(err)
-                # if any exceptions return with first exception
-                if len (exceptions) > 0:
-                    future.set_exception(exceptions[0])
-                    return
-                # else return first result
-                else:
-                    futures_list = list(complete)
-                    are_all_canceled = all(f._state == 'CANCELLED' for f in futures_list)
-                    if are_all_canceled and future._state == 'PENDING':
-                        future.set_exception(ExchangeClosedByUser('Connection closed by the user'))
+                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)
 
-                    # handle wait_for scenario
-                    if are_all_canceled and future._state == 'CANCELLED':
-                        return
+                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 = futures_list[0]
 
-                    first_result = first.result()
-                    future.set_result(first_result)
-            else:
-                future.set_exception(exception)
+                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

ccxt/async_support/base/ws/order_book_side.py

@@ -21,6 +21,9 @@ class OrderBookSide(list):
         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]

ccxt/async_support/bequant.py

@@ -16,7 +16,7 @@ class bequant(hitbtc, ImplicitAPI):
             'countries': ['MT'],  # Malta
             'pro': True,
             'urls': {
-                'logo': 'https://user-images.githubusercontent.com/1294454/55248342-a75dfe00-525a-11e9-8aa2-05e9dca943c6.jpg',
+                'logo': 'https://github.com/user-attachments/assets/0583ef1f-29fe-4b7c-8189-63565a0e2867',
                 'api': {
                     'public': 'https://api.bequant.io/api/3',
                     'private': 'https://api.bequant.io/api/3',