exchanges-wrapper 2.1.23__tar.gz → 2.1.24__tar.gz

{exchanges_wrapper-2.1.23 → exchanges_wrapper-2.1.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: exchanges-wrapper
-Version: 2.1.23
+Version: 2.1.24
 Summary: REST API and WebSocket asyncio wrapper with grpc powered multiplexer server
 Author-email: Thomas Marchand <thomas.marchand@tuta.io>, Jerry Fedorenko <jerry.fedorenko@yahoo.com>
 Requires-Python: >=3.9

{exchanges_wrapper-2.1.23 → exchanges_wrapper-2.1.24}/exchanges_wrapper/__init__.py

@@ -12,7 +12,7 @@ __maintainer__ = "Jerry Fedorenko"
 __contact__ = "https://github.com/DogsTailFarmer"
 __email__ = "jerry.fedorenko@yahoo.com"
 __credits__ = ["https://github.com/DanyaSWorlD"]
-__version__ = "2.1.23"
+__version__ = "2.1.24"
 
 from pathlib import Path
 import shutil

{exchanges_wrapper-2.1.23 → exchanges_wrapper-2.1.24}/exchanges_wrapper/client.py

@@ -10,9 +10,10 @@ import pyotp
 from expiringdict import ExpiringDict
 import uuid
 from decimal import Decimal, ROUND_HALF_DOWN
+import inspect
 
 from exchanges_wrapper.http_client import HttpClient
-from exchanges_wrapper.errors import ExchangePyError
+from exchanges_wrapper.errors import ExchangePyError, ExchangeError
 from exchanges_wrapper.web_sockets import UserEventsDataStream, \
     MarketEventsDataStream, \
     BfxPrivateEventsDataStream, \
@@ -33,7 +34,7 @@ USER_DATA_STREAM = "/api/v3/userDataStream"
 ORDER_ENDPOINT = "/api/v3/order"
 
 def fallback_warning(exchange, symbol=None):
-    logger.warning(f"{exchange}:{symbol}: Fallback to HTTP API call")
+    logger.warning(f"Called by: {inspect.stack()[1][3]}: {exchange}:{symbol}: Fallback to HTTP API call")
 
 def truncate(f, n):
     return math.floor(f * 10 ** n) / 10 ** n
@@ -977,14 +978,21 @@ class Client:
                 b_res = bfx.order(res, response_type=response_type)
                 self.active_order(b_res['orderId'], b_res['origQty'], b_res['executedQty'])
         elif self.exchange == 'huobi':
-            if origin_client_order_id:
-                params = {'clientOrderId': str(origin_client_order_id)}
-                res = await self.http.send_api_call("/v1/order/orders/getClientOrder", signed=True, **params)
+            try:
+                if origin_client_order_id:
+                    params = {'clientOrderId': str(origin_client_order_id)}
+                    res = await self.http.send_api_call("/v1/order/orders/getClientOrder", signed=True, **params)
+                else:
+                    res = await self.http.send_api_call(f"v1/order/orders/{order_id}", signed=True)
+            except ExchangeError as ex:
+                # https://huobiapi.github.io/docs/spot/v1/en/#get-the-order-detail-of-an-order-based-on-client-order-id
+                # If an order is created via API, then it's no longer queryable after being cancelled for 2 hours
+                if "base-record-invalid" in ex:
+                    return hbp.order_cancelled(symbol, order_id, origin_client_order_id)
             else:
-                res = await self.http.send_api_call(f"v1/order/orders/{order_id}", signed=True)
-            if res:
-                b_res = hbp.order(res, response_type=response_type)
-                self.active_order(b_res['orderId'], b_res['origQty'], b_res['executedQty'])
+                if res:
+                    b_res = hbp.order(res, response_type=response_type)
+                    self.active_order(b_res['orderId'], b_res['origQty'], b_res['executedQty'])
         elif self.exchange == 'okx':
             params = {'instId': self.symbol_to_okx(symbol),
                       'ordId': str(order_id),

{exchanges_wrapper-2.1.23 → exchanges_wrapper-2.1.24}/exchanges_wrapper/exch_srv.py

@@ -179,7 +179,7 @@ class Martin(mr.MartinBase):
             client.request_event.clear()
 
         try:
-            res = await asyncio.wait_for(getattr(client, client_method_name)(**kwargs), timeout=HEARTBEAT * 60)
+            res = await asyncio.wait_for(getattr(client, client_method_name)(**kwargs), timeout=90)
         except asyncio.exceptions.CancelledError:
             raise GRPCError(status=Status.UNAVAILABLE, message=f"{msg_header} Server Shutdown")
         except asyncio.exceptions.TimeoutError:
@@ -745,10 +745,6 @@ class Martin(mr.MartinBase):
         return response
 
     async def start_stream(self, request: mr.StartStreamRequest) -> mr.SimpleResponse:
-        if request.update_max_queue_size:
-            global MAX_QUEUE_SIZE
-            MAX_QUEUE_SIZE += int(MAX_QUEUE_SIZE / 10)
-            logger.info(f"MAX_QUEUE_SIZE was updated: new value is {MAX_QUEUE_SIZE}")
         open_client = OpenClient.get_client(request.client_id)
         client = open_client.client
         response = mr.SimpleResponse()
@@ -808,7 +804,9 @@ async def event_handler(_queue, client, trade_id, _event_type, event):
         logger.warning(f"For {_event_type} asyncio queue full and wold be closed")
         client.stream_queue.get(trade_id, set()).discard(_queue)
         await stop_stream(client, trade_id)
-
+        global MAX_QUEUE_SIZE
+        MAX_QUEUE_SIZE += int(MAX_QUEUE_SIZE / 10)
+        logger.info(f"MAX_QUEUE_SIZE was updated: new value is {MAX_QUEUE_SIZE}")
 
 def is_port_in_use(port: int) -> bool:
     import socket

{exchanges_wrapper-2.1.23 → exchanges_wrapper-2.1.24}/exchanges_wrapper/http_client.py

@@ -23,7 +23,7 @@ STATUS_UNAUTHORIZED = 401
 STATUS_FORBIDDEN = 403
 STATUS_I_AM_A_TEAPOT = 418  # HTTP status code for IPAddressBanned
 ERR_TIMESTAMP_OUTSIDE_RECV_WINDOW = "Timestamp for this request is outside of the recvWindow"
-
+TIMEOUT = aiohttp.ClientTimeout(total=60)
 
 class HttpClient:
     def __init__(self, params: dict):
@@ -34,8 +34,8 @@ class HttpClient:
         self.exchange = params['exchange']
         self.test_net = params['test_net']
         self.rate_limit_reached = False
-        self.rest_cycle_busy = None
-        self.session = aiohttp.ClientSession()
+        self.rest_cycle_lock = asyncio.Lock()
+        self.session = None
         self._session_mutex = asyncio.Lock()
         self.ex_imps = {}  #  exchanges implementation
         self.declare_exchanges_implementation()
@@ -51,9 +51,9 @@ class HttpClient:
         }
 
     async def _create_session_if_required(self):
-        if self.session.closed:
+        if self.session is None or self.session.closed:
             async with self._session_mutex:
-                self.session = aiohttp.ClientSession()
+                self.session = aiohttp.ClientSession(timeout=TIMEOUT)
 
     async def handle_errors(self, response):
         if response.status >= 500:
@@ -128,11 +128,10 @@ class HttpClient:
         await self._create_session_if_required()
         try:
             async with self.session.request(method, url, timeout=timeout, **query_kwargs) as response:
-                self.rest_cycle_busy = False
                 return await self.handle_errors(response)
-        except (aiohttp.ClientOSError, aiohttp.ServerDisconnectedError):
+        except (aiohttp.ClientConnectionError, asyncio.exceptions.TimeoutError):
             await self.session.close()
-            raise ExchangeError("HTTP ClientOSError or ServerDisconnectedError, the connection will be restored")
+            raise ExchangeError("HTTP ClientConnectionError, the connection will be restored")
 
     async def _binance_request(self, path, method, signed, send_api_key, endpoint, timeout, **kwargs):
         _endpoint = endpoint or self.endpoint
@@ -162,25 +161,24 @@ class HttpClient:
         if bfx_post and "params" in kwargs:
             query_kwargs['data'] = _params
 
-        # To avoid breaking the correct sequence Nonce value
-        while self.rest_cycle_busy:
-            await asyncio.sleep(0.1)
-        self.rest_cycle_busy = True
-
         if signed:
-            ts = int(time.time() * 1000)
-            query_kwargs["headers"]["Content-Type"] = AJ
-            if bfx_post:
-                query_kwargs['data'] = _params
-            if send_api_key:
-                query_kwargs["headers"]["bfx-apikey"] = self.api_key
-            signature_payload = f'/api/{path}{ts}'
-            if _params:
-                signature_payload += f"{_params}"
-            query_kwargs["headers"]["bfx-signature"] = generate_signature(self.exchange,
-                                                                          self.api_secret,
-                                                                          signature_payload)
-            query_kwargs["headers"]["bfx-nonce"] = str(ts)
+            async with self.rest_cycle_lock:
+                ts = int(time.time() * 1000000)
+                query_kwargs["headers"]["Content-Type"] = AJ
+                if bfx_post:
+                    query_kwargs['data'] = _params
+                if send_api_key:
+                    query_kwargs["headers"]["bfx-apikey"] = self.api_key
+                signature_payload = f'/api/{path}{ts}'
+                if _params:
+                    signature_payload += f"{_params}"
+                query_kwargs["headers"]["bfx-signature"] = generate_signature(self.exchange,
+                                                                              self.api_secret,
+                                                                              signature_payload)
+                query_kwargs["headers"]["bfx-nonce"] = str(ts)
+
+                return await self.send_request(method, url, timeout, query_kwargs)
+
         return await self.send_request(method, url, timeout, query_kwargs)
 
     async def _bybit_request(self, path, method, signed, _send_api_key, endpoint, timeout, **kwargs):

{exchanges_wrapper-2.1.23 → exchanges_wrapper-2.1.24}/exchanges_wrapper/parsers/huobi.py

@@ -170,6 +170,23 @@ def order(res: {}, response_type=None) -> {}:
             "side": side,
         }
 
+def order_cancelled(symbol, order_id=None, origin_client_order_id=None,) -> {}:
+    return {
+        "symbol": symbol,
+        "origClientOrderId": origin_client_order_id,
+        "orderId": order_id,
+        "orderListId": -1,
+        "clientOrderId": origin_client_order_id,
+        "transactTime": int(time.time() * 1000),
+        "price": "0",
+        "origQty": "0",
+        "executedQty": "0",
+        "cummulativeQuoteQty": "0",
+        "status": 'CANCELED',
+        "timeInForce": "GTC",
+        "type": "LIMIT",
+        "side": '',
+    }
 
 def account_information(res: {}) -> {}:
     balances = []

{exchanges_wrapper-2.1.23 → exchanges_wrapper-2.1.24}/exchanges_wrapper/web_sockets.py

@@ -233,7 +233,10 @@ class EventsDataStream:
     async def bybit_heartbeat(self, req_id, interval=20):
         while True:
             await asyncio.sleep(interval)
-            await self.websocket.send(json.dumps({"req_id": req_id, "op": "ping"}))
+            try:
+                await self.websocket.send(json.dumps({"req_id": req_id, "op": "ping"}))
+            except (ConnectionClosed, asyncio.exceptions.TimeoutError):
+                pass  # handled elsewhere
 
     async def htx_keepalive(self, interval=60):
         await asyncio.sleep(interval * 10)