exchanges-wrapper 2.1.7__tar.gz → 2.1.9__tar.gz

{exchanges_wrapper-2.1.7 → exchanges_wrapper-2.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: exchanges-wrapper
-Version: 2.1.7
+Version: 2.1.9
 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.7 → exchanges_wrapper-2.1.9}/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.7"
+__version__ = "2.1.9"
 
 from pathlib import Path
 import shutil

{exchanges_wrapper-2.1.7 → exchanges_wrapper-2.1.9}/exchanges_wrapper/client.py

@@ -22,10 +22,10 @@ from exchanges_wrapper.web_sockets import UserEventsDataStream, \
     BBTPrivateEventsDataStream
 from exchanges_wrapper.definitions import OrderType
 from exchanges_wrapper.events import Events
-import exchanges_wrapper.bitfinex_parser as bfx
-import exchanges_wrapper.huobi_parser as hbp
-import exchanges_wrapper.okx_parser as okx
-import exchanges_wrapper.bybit_parser as bbt
+import exchanges_wrapper.parsers.bitfinex_parser as bfx
+import exchanges_wrapper.parsers.huobi_parser as hbp
+import exchanges_wrapper.parsers.okx_parser as okx
+import exchanges_wrapper.parsers.bybit_parser as bbt
 from crypto_ws_api.ws_session import UserWSSession
 
 logger = logging.getLogger(__name__)
@@ -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
@@ -117,6 +123,7 @@ class Client:
         return res
 
     async def load(self, symbol):
+        logger.info(f"Try load {self.exchange}:{symbol} info...")
         infos = await self.fetch_exchange_info(symbol)
         if not infos.get('serverTime'):
             raise UserWarning("Can't get exchange info, check availability and operational status of the exchange")
@@ -144,6 +151,7 @@ class Client:
         # load rate limits
         self.rate_limits = infos["rateLimits"]
         self.loaded = True
+        logger.info(f"Info for {self.exchange}:{symbol} loaded successfully")
 
     async def close(self):
         await self.session.close()
@@ -174,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
@@ -188,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
@@ -200,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}")
@@ -1177,18 +1184,19 @@ class Client:
             orders = await self.fetch_open_orders(trade_id, symbol, receive_window=receive_window, response_type=True)
             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)
-                    or await self.http.send_api_call(
+            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'):
+                logger.debug(f"cancel_all_orders.bitfinex {orders_id}: res1: {res}")
+                res = await self.http.send_api_call(
                         "v2/auth/w/order/cancel/multi",
                         method="POST",
                         signed=True,
-                        **params,
-                    )
-            )
-            if res and res[6] == 'SUCCESS':
-                return bfx.orders(res[4], response_type=True, cancelled=True)
-            logger.debug(f"bitfinex: cancel_all_orders.res: {res}")
+                        **params
+                )
+            if res and isinstance(res, list) and res[6] == 'SUCCESS':
+                binance_res = bfx.orders(res[4], response_type=True, cancelled=True)
+            else:
+                logger.debug(f"bitfinex: cancel_all_orders.res: {res}")
 
         elif self.exchange == 'huobi':
             orders = await self.fetch_open_orders(trade_id, symbol, receive_window=receive_window, response_type=True)
@@ -1246,12 +1254,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)
@@ -1264,6 +1272,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.7 → exchanges_wrapper-2.1.9}/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.7 → exchanges_wrapper-2.1.9}/exchanges_wrapper/exch_srv.py

@@ -160,9 +160,11 @@ class Martin(mr.MartinBase):
         logger.info(f"OpenClientConnection start trade: {request.account_name}:{request.trade_id}")
         client_id = OpenClient.get_id(request.account_name)
         if client_id:
+            logger.debug(f"OpenClientConnection: {request.account_name}:{request.trade_id}:{client_id}")
             open_client = OpenClient.get_client(client_id)
             open_client.client.http.rate_limit_reached = False
         else:
+            logger.debug(f"OpenClientConnection: {request.account_name}:{request.trade_id}: set new client_id")
             try:
                 open_client = OpenClient(request.account_name)
                 client_id = id(open_client)
@@ -183,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
@@ -849,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.7/exchanges_wrapper → exchanges_wrapper-2.1.9/exchanges_wrapper/parsers}/bybit_parser.py

@@ -374,7 +374,12 @@ def on_trade_update(res: dict) -> dict:
     last_executed_price = res.get("execPrice", res.get("avgPrice"))
     last_quote_asset_transacted = res.get("execValue", cumulative_quote_asset)
 
-    status = 'NEW' if leaves_qty == order_quantity else 'PARTIALLY_FILLED' if leaves_qty > 0 else 'FILLED'
+    if leaves_qty == order_quantity:
+        status = 'NEW'
+    elif leaves_qty > 0:
+        status = 'PARTIALLY_FILLED'
+    else:
+        status = 'FILLED'
 
     return {
         "e": "executionReport",

{exchanges_wrapper-2.1.7 → exchanges_wrapper-2.1.9}/exchanges_wrapper/web_sockets.py

@@ -10,10 +10,10 @@ from datetime import datetime, timezone
 from urllib.parse import urlencode, urlparse
 import websockets
 
-import exchanges_wrapper.bitfinex_parser as bfx
-import exchanges_wrapper.huobi_parser as hbp
-import exchanges_wrapper.okx_parser as okx
-import exchanges_wrapper.bybit_parser as bbt
+import exchanges_wrapper.parsers.bitfinex_parser as bfx
+import exchanges_wrapper.parsers.huobi_parser as hbp
+import exchanges_wrapper.parsers.okx_parser as okx
+import exchanges_wrapper.parsers.bybit_parser as bbt
 from crypto_ws_api.ws_session import generate_signature
 from exchanges_wrapper import LOG_PATH
 
@@ -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.7 → exchanges_wrapper-2.1.9}/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",