exchanges-wrapper 2.1.8__tar.gz → 2.1.10__tar.gz

{exchanges_wrapper-2.1.8 → exchanges_wrapper-2.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: exchanges-wrapper
-Version: 2.1.8
+Version: 2.1.10
 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
@@ -11,7 +11,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: Unix
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: MacOS
-Requires-Dist: crypto-ws-api==2.0.8
+Requires-Dist: crypto-ws-api==2.0.9
 Requires-Dist: grpcio==1.62.0
 Requires-Dist: pyotp~=2.9.0
 Requires-Dist: simplejson==3.19.2

{exchanges_wrapper-2.1.8 → exchanges_wrapper-2.1.10}/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.8"
+__version__ = "2.1.10"
 
 from pathlib import Path
 import shutil

{exchanges_wrapper-2.1.8 → exchanges_wrapper-2.1.10}/exchanges_wrapper/client.py

@@ -108,6 +108,12 @@ class Client:
         self.main_account_uid = None
         self.ledgers_id = []
         self.ts_start = {}
+        self.tasks = set()
+
+    def tasks_manage(self, coro):
+        _t = asyncio.create_task(coro)
+        self.tasks.add(_t)
+        _t.add_done_callback(self.tasks.discard)
 
     async def fetch_object(self, key):
         res = None
@@ -145,7 +151,7 @@ class Client:
         # load rate limits
         self.rate_limits = infos["rateLimits"]
         self.loaded = True
-        logger.info(f"Info for {self.exchange}:{symbol} loaded success")
+        logger.info(f"Info for {self.exchange}:{symbol} loaded successfully")
 
     async def close(self):
         await self.session.close()
@@ -176,7 +182,7 @@ class Client:
             user_data_stream = BBTPrivateEventsDataStream(self, self.endpoint_ws_auth, self.exchange, _trade_id)
         if user_data_stream:
             self.data_streams[_trade_id] |= {user_data_stream}
-            asyncio.ensure_future(user_data_stream.start())
+            self.tasks_manage(user_data_stream.start())
             timeout = STATUS_TIMEOUT / 0.1
             while not user_data_stream.wss_started:
                 timeout -= 1
@@ -190,8 +196,7 @@ class Client:
         if self.exchange == 'binance':
             market_data_stream = MarketEventsDataStream(self, self.endpoint_ws_public, self.exchange, _trade_id)
             self.data_streams[_trade_id] |= {market_data_stream}
-            asyncio.ensure_future(market_data_stream.start())
-            # start_list.append(market_data_stream.start())
+            self.tasks_manage(market_data_stream.start())
         else:
             for channel in _events:
                 # https://www.okx.com/help-center/changes-to-v5-api-websocket-subscription-parameter-and-url
@@ -202,7 +207,7 @@ class Client:
                 #
                 market_data_stream = MarketEventsDataStream(self, _endpoint, self.exchange, _trade_id, channel)
                 self.data_streams[_trade_id] |= {market_data_stream}
-                asyncio.ensure_future(market_data_stream.start())
+                self.tasks_manage(market_data_stream.start())
 
     async def stop_events_listener(self, _trade_id):
         logger.info(f"Stop events listener data streams for {_trade_id}")
@@ -339,7 +344,7 @@ class Client:
                 "v2/tickers",
                 send_api_key=False,
                 endpoint=self.endpoint_api_public,
-                symbols=bfx.get_symbols(symbols_details)
+                symbols=bfx.get_symbols(symbols_details, symbol)
             )
             if symbols_details and tickers:
                 binance_res = bfx.exchange_info(symbols_details, tickers, symbol)
@@ -874,18 +879,22 @@ class Client:
             if new_client_order_id:
                 params["cid"] = new_client_order_id
                 self.active_order(new_client_order_id, quantity)
-            res = (
-                    await self.user_wss_session.handle_request(trade_id, "on", _params=params)
-                    or await self.http.send_api_call(
-                        "v2/auth/w/order/submit",
-                        method="POST",
-                        signed=True,
-                        **params,
-                    )
-            )
+
+            res = await self.user_wss_session.handle_request(trade_id, "on", _params=params)
+
+            if not res or (res and isinstance(res, list) and res[6] != 'SUCCESS'):
+                logger.debug(f"create_order.bitfinex {new_client_order_id}: {res}")
+                res = await self.http.send_api_call(
+                    "v2/auth/w/order/submit",
+                    method="POST",
+                    signed=True,
+                    **params
+                )
             if res and isinstance(res, list) and res[6] == 'SUCCESS':
                 self.active_order(res[4][0][0], quantity)
                 binance_res = bfx.order(res[4][0], response_type=False)
+            else:
+                logger.debug(f"create_order.bitfinex {new_client_order_id}: {res}")
         elif self.exchange == 'huobi':
             params = {
                 'account-id': str(self.account_id),
@@ -961,9 +970,7 @@ class Client:
             response_type=None,
     ):
         self.assert_symbol(symbol)
-        if self.exchange == 'bitfinex' and not order_id:
-            raise ValueError("This query requires an order_id")
-        elif self.exchange in ('binance', 'huobi', 'okx', 'bybit') and not order_id and not origin_client_order_id:
+        if not order_id and not origin_client_order_id:
             raise ValueError("This query requires an order_id or an origin_client_order_id")
 
         b_res = {}
@@ -990,20 +997,28 @@ class Client:
                     )
             )
         elif self.exchange == 'bitfinex':
-            params = {'id': [order_id]}
-            res = await self.http.send_api_call(
+            params = {}
+            if order_id:
+                params['id'] = [order_id]
+            _res = await self.http.send_api_call(
                 f"v2/auth/r/orders/{self.symbol_to_bfx(symbol)}",
                 method="POST",
                 signed=True,
                 **params
-            ) or await self.http.send_api_call(
-                f"v2/auth/r/orders/{self.symbol_to_bfx(symbol)}/hist",
-                method="POST",
-                signed=True,
-                **params
             )
+            res = bfx.find_order(_res, order_id, origin_client_order_id)
+            if not res:
+                if not order_id:
+                    params['start'] = int(time.time() * 1000) - 600000  # 10 mins
+                _res = await self.http.send_api_call(
+                    f"v2/auth/r/orders/{self.symbol_to_bfx(symbol)}/hist",
+                    method="POST",
+                    signed=True,
+                    **params
+                )
+                res = bfx.find_order(_res, order_id, origin_client_order_id)
             if res:
-                b_res = bfx.order(res[0], response_type=response_type)
+                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:
@@ -1180,7 +1195,7 @@ class Client:
             orders_id = [order.get('orderId') for order in orders]
             params = {'id': orders_id}
             res = await self.user_wss_session.handle_request(trade_id, "oc_multi", _params=params)
-            if res is None or (res and isinstance(res, list) and res[6] == 'ERROR'):
+            if not res or (res and isinstance(res, list) and res[6] != 'SUCCESS'):
                 logger.debug(f"cancel_all_orders.bitfinex {orders_id}: res1: {res}")
                 res = await self.http.send_api_call(
                         "v2/auth/w/order/cancel/multi",
@@ -1249,12 +1264,12 @@ class Client:
             params = {'category': 'spot', 'symbol': symbol}
             res, _ = await self.http.send_api_call("/v5/order/cancel-all", method="POST", signed=True, **params)
 
-            tasks = []
+            tasks = set()
             for order in res.get('list', []):
                 _id = order.get('orderId')
-                task = asyncio.ensure_future(self.fetch_object(f"oc-{_id}"))
+                task = asyncio.create_task(self.fetch_object(f"oc-{_id}"))
                 task.set_name(f"{_id}")
-                tasks.append(task)
+                tasks.add(task)
 
             if tasks:
                 done, pending = await asyncio.wait(tasks, timeout=STATUS_TIMEOUT)
@@ -1267,6 +1282,7 @@ class Client:
                             _res = await self.fetch_order(trade_id, symbol, order_id=_id, response_type=True)
                             binance_res.append(_res)
                     pending.clear()
+                tasks.clear()
 
         return binance_res
 

{exchanges_wrapper-2.1.8 → exchanges_wrapper-2.1.10}/exchanges_wrapper/events.py

@@ -1,5 +1,4 @@
-import asyncio
-import functools
+
 from collections import defaultdict
 import logging
 
@@ -11,7 +10,6 @@ logger = logging.getLogger(__name__)
 # based on: https://stackoverflow.com/a/2022629/10144963
 class Handlers(list):
     async def __call__(self, *args, **kwargs):
-        loop = asyncio.get_running_loop()
         trade_id = kwargs.pop('trade_id', None)
         _trade_id = None
         for func in self:
@@ -20,12 +18,7 @@ class Handlers(list):
             except Exception as ex:  # skipcq: PYL-W0703
                 logger.warning(f"Handlers error when try get trade_id: {ex}")
             if trade_id is None or trade_id == _trade_id:
-                if asyncio.iscoroutinefunction(func):
-                    await func(*args, **kwargs)
-                    continue
-                if kwargs:
-                    func = functools.partial(func, **kwargs)
-                loop.run_in_executor(None, func, *args)
+                await func(*args, **kwargs)
 
     def __repr__(self):
         return f"Handlers({list.__repr__(self)})"

{exchanges_wrapper-2.1.8 → exchanges_wrapper-2.1.10}/exchanges_wrapper/exch_srv.py

@@ -185,14 +185,16 @@ class Martin(mr.MartinBase):
                 raise GRPCError(status=Status.FAILED_PRECONDITION, message=str(ex))
 
         try:
-            await open_client.client.load(request.symbol)
+            await asyncio.wait_for(open_client.client.load(request.symbol), timeout=HEARTBEAT * 60)
         except asyncio.CancelledError:
             pass  # Task cancellation should not be logged as an error
+        except asyncio.exceptions.TimeoutError:
+            await OpenClient.get_client(client_id).client.session.close()
+            OpenClient.remove_client(request.account_name)
+            raise GRPCError(status=Status.UNAVAILABLE, message=f"'{open_client.name}' timeout error")
         except Exception as ex:
             logger.warning(f"OpenClientConnection for '{open_client.name}' exception: {ex}")
             logger.debug(f"Exception traceback: {traceback.format_exc()}")
-            await OpenClient.get_client(client_id).client.session.close()
-            OpenClient.remove_client(request.account_name)
             raise GRPCError(status=Status.RESOURCE_EXHAUSTED, message=str(ex))
 
         # Set rate_limiter
@@ -851,7 +853,7 @@ async def amain(host: str = '127.0.0.1', port: int = 50051):
         for oc in OpenClient.open_clients:
             await oc.client.session.close()
 
-        [task.cancel() for task in asyncio.all_tasks() if not task.done()]
+        [task.cancel() for task in asyncio.all_tasks() if not task.done() and task is not asyncio.current_task()]
 
 
 def main():

{exchanges_wrapper-2.1.8 → exchanges_wrapper-2.1.10}/exchanges_wrapper/parsers/bitfinex_parser.py

@@ -50,13 +50,13 @@ class OrderBook:
         return self
 
 
-def get_symbols(symbols_details: []) -> str:
+def get_symbols(symbols_details: [], symbol) -> str:
     symbols = []
     res = ",t"
     for symbol_details in symbols_details:
-        symbol = symbol_details['pair']
-        if 'f0' not in symbol:
-            symbols.append(symbol.upper())
+        _symbol = symbol_details['pair']
+        if 'f0' not in _symbol and _symbol.replace(":", "").upper() == symbol:
+            symbols.append(_symbol.upper())
     return f"t{res.join(symbols)}"
 
 
@@ -623,3 +623,16 @@ def funding_wallet(res: []) -> []:
                 balances.append(_binance_res)
 
     return balances
+
+
+def find_order(_res, order_id, origin_client_order_id):
+    res = []
+    if _res:
+        if order_id:
+            res = _res[0]
+        else:
+            for i in _res:
+                if i[2] == int(origin_client_order_id):
+                    res = i
+                    break
+    return res

{exchanges_wrapper-2.1.8 → exchanges_wrapper-2.1.10}/exchanges_wrapper/web_sockets.py

@@ -48,7 +48,7 @@ class EventsDataStream:
         self.wss_event_buffer = {}
         self._order_book = None
         self._price = None
-        self.tasks_list = []
+        self.tasks = set()
         self.wss_started = False
 
     async def start(self):
@@ -84,8 +84,13 @@ class EventsDataStream:
             await self.websocket.close(code=4000)
 
     def tasks_cancel(self):
-        [task.cancel() for task in self.tasks_list if not task.done()]
-        self.tasks_list.clear()
+        [task.cancel() for task in self.tasks if not task.done()]
+        self.tasks.clear()
+
+    def tasks_manage(self, coro):
+        _t = asyncio.create_task(coro)
+        self.tasks.add(_t)
+        _t.add_done_callback(self.tasks.discard)
 
     async def _handle_event(self, *args):
         pass  # meant to be overridden in a subclass
@@ -110,8 +115,7 @@ class EventsDataStream:
                 return
             elif ((msg_data.get("ret_msg") == "subscribe" or msg_data.get("op") in ("auth", "subscribe"))
                   and msg_data.get("success")):
-                _task = asyncio.ensure_future(self.bybit_heartbeat(ch_type or "private"))
-                self.tasks_list.append(_task)
+                self.tasks_manage(self.bybit_heartbeat(ch_type or "private"))
                 if msg_data["op"] == "subscribe" and msg_data["success"] and not msg_data["ret_msg"]:
                     self.wss_started = True
             elif ((msg_data.get("ret_msg") == "subscribe" or msg_data.get("op") in ("auth", "subscribe"))
@@ -602,8 +606,7 @@ class UserEventsDataStream(EventsDataStream):
 
     async def start_wss(self):
         logger.info(f"Start User WSS for {self.exchange}")
-        _task = asyncio.ensure_future(self._heartbeat(self.listen_key))
-        self.tasks_list.append(_task)
+        self.tasks_manage(self._heartbeat(self.listen_key))
         try:
             await self.ws_listener()
         finally:

{exchanges_wrapper-2.1.8 → exchanges_wrapper-2.1.10}/pyproject.toml

@@ -17,7 +17,7 @@ dynamic = ["version", "description"]
 requires-python = ">=3.9"
 
 dependencies = [
-    "crypto-ws-api==2.0.8",
+    "crypto-ws-api==2.0.9",
     "grpcio==1.62.0",
     "pyotp~=2.9.0",
     "simplejson==3.19.2",