exchanges-wrapper 2.1.41__tar.gz → 2.1.43__tar.gz

{exchanges_wrapper-2.1.41 → exchanges_wrapper-2.1.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: exchanges-wrapper
-Version: 2.1.41
+Version: 2.1.43
 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.10
@@ -12,10 +12,10 @@ Classifier: Operating System :: Unix
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: MacOS
 License-File: LICENSE.md
-Requires-Dist: crypto-ws-api==2.1.0
+Requires-Dist: crypto-ws-api==2.1.4
 Requires-Dist: pyotp==2.9.0
-Requires-Dist: simplejson==3.20.1
-Requires-Dist: aiohttp~=3.12.13
+Requires-Dist: simplejson==3.20.2
+Requires-Dist: aiohttp~=3.13.2
 Requires-Dist: expiringdict~=1.2.2
 Requires-Dist: betterproto==2.0.0b7
 Requires-Dist: grpclib~=0.4.8

{exchanges_wrapper-2.1.41 → exchanges_wrapper-2.1.43}/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.41"
+__version__ = "2.1.43"
 
 from pathlib import Path
 import shutil
@@ -33,9 +33,11 @@ __all__ = [
     'LOG_PATH',
     'WORK_PATH',
     'LOG_FILE',
-    'CONFIG_FILE'
+    'CONFIG_FILE',
+    'DEBUG_LOG'
 ]
 
+DEBUG_LOG = 'debug'  # The exchange for which log files, separated by trade_id with DEBUG level, will be generated
 WORK_PATH = Path(Path.home(), ".MartinBinance")
 CONFIG_PATH = Path(WORK_PATH, "config")
 CONFIG_FILE = Path(CONFIG_PATH, "exch_srv_cfg.toml")

{exchanges_wrapper-2.1.41 → exchanges_wrapper-2.1.43}/exchanges_wrapper/client.py

@@ -25,16 +25,18 @@ import exchanges_wrapper.parsers.bitfinex as bfx
 import exchanges_wrapper.parsers.huobi as hbp
 import exchanges_wrapper.parsers.okx as okx
 import exchanges_wrapper.parsers.bybit as bbt
-from crypto_ws_api.ws_session import UserWSSession
+from crypto_ws_api.ws_session import UserWSSession, tasks_manage, tasks_cancel
 
 logger = logging.getLogger(__name__)
 
 STATUS_TIMEOUT = 5  # sec, also use for lifetime limit for inactive order (Bitfinex) as 60 * STATUS_TIMEOUT
 ORDER_ENDPOINT = "/api/v3/order"
 
+
 def fallback_warning(exchange, symbol=None):
     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
 
@@ -44,6 +46,19 @@ def any2str(_x) -> str:
 
 
 class Client:
+    __slots__ = (
+        'exchange', 'sub_account', 'test_net', 'api_key', 'api_secret',
+        'passphrase', 'endpoint_api_public', 'endpoint_ws_public',
+        'endpoint_api_auth', 'endpoint_ws_auth', 'endpoint_ws_api',
+        'ws_add_on', 'master_email', 'master_name', 'two_fa', 'http',
+        'user_session', 'symbols', 'highest_precision',
+        'rate_limits', 'data_streams', 'active_orders', 'wss_buffer',
+        'stream_queue', 'on_order_update_queues', 'account_id',
+        'account_uid', 'main_account_id', 'main_account_uid',
+        'ledgers_id', 'ts_start', 'tasks', 'request_event',
+        '_events'
+    )
+
     def __init__(self, acc: dict):
         self.exchange = acc['exchange']
         self.sub_account = acc['sub_account']
@@ -83,7 +98,6 @@ class Client:
         else:
             self.user_session = None
         #
-        self.loaded = False
         self.symbols = {}
         self.highest_precision = None
         self.rate_limits = None
@@ -98,15 +112,10 @@ class Client:
         self.main_account_uid = None
         self.ledgers_id = []
         self.ts_start = {}
-        self.tasks = set()
+        self.tasks: dict[str, set] = {}
         self.request_event = asyncio.Event()
         self.request_event.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
         while res is None:
@@ -140,12 +149,11 @@ class Client:
                 logger.info(f"Main ByBit account UID: {self.main_account_uid}, sub-UID: {self.account_uid}")
         # 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):
-        if self.http and self.http.session:
-            await self.http.session.close()
+        if self.http:
+            await self.http.close_session()
 
     @property
     def events(self):
@@ -154,9 +162,8 @@ class Client:
             self._events = Events()  # skipcq: PYL-W0201
         return self._events
 
-    async def start_user_events_listener(self, _trade_id, symbol):
+    def start_user_events_listener(self, _trade_id, symbol):
         logger.info(f"Start '{self.exchange}' user events listener for {_trade_id}")
-        user_data_stream = None
         if self.exchange == 'binance':
             user_data_stream = UserEventsDataStream(self, self.endpoint_ws_api, self.exchange, _trade_id)
         elif self.exchange == 'bitfinex':
@@ -173,24 +180,27 @@ class Client:
             )
         elif self.exchange == 'bybit':
             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}
-            self.tasks_manage(user_data_stream.start())
-            timeout = STATUS_TIMEOUT / 0.1
-            while not user_data_stream.wss_started:
-                timeout -= 1
-                if not timeout:
-                    logger.warning(f"{self.exchange} user WSS start timeout reached for {_trade_id}")
-                    break
-                await asyncio.sleep(0.1)
+        else:
+            raise UserWarning(f"User Data Stream: exchange {self.exchange} not serviced")
+
+        self.data_streams[_trade_id] |= {user_data_stream}
+
+        trade_tasks = self.tasks.pop(_trade_id, set())
+        tasks_manage(trade_tasks, user_data_stream.start(), f"user_data_stream-{self.exchange}-{_trade_id}")
+        self.tasks[_trade_id] = trade_tasks
 
     def start_market_events_listener(self, _trade_id):
         _events = self.events.registered_streams.get(self.exchange, {}).get(_trade_id, set())
         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}
-            self.tasks_manage(market_data_stream.start())
+
+            trade_tasks = self.tasks.pop(_trade_id, set())
+            tasks_manage(trade_tasks, market_data_stream.start(), f"market_data_stream-{self.exchange}-{_trade_id}")
+            self.tasks[_trade_id] = trade_tasks
+
         else:
+            trade_tasks = self.tasks.pop(_trade_id, set())
             for channel in _events:
                 # https://www.okx.com/help-center/changes-to-v5-api-websocket-subscription-parameter-and-url
                 if self.exchange == 'okx' and 'kline' in channel:
@@ -200,18 +210,24 @@ class Client:
                 #
                 market_data_stream = MarketEventsDataStream(self, _endpoint, self.exchange, _trade_id, channel)
                 self.data_streams[_trade_id] |= {market_data_stream}
-                self.tasks_manage(market_data_stream.start())
+                tasks_manage(
+                    trade_tasks, market_data_stream.start(), f"market_data_stream-{self.exchange}-{channel}-{_trade_id}"
+                )
+            self.tasks[_trade_id] = trade_tasks
 
     async def stop_events_listener(self, _trade_id):
         logger.info(f"Stop events listener data streams for {_trade_id}")
         stopped_data_stream = self.data_streams.pop(_trade_id, set())
         for data_stream in stopped_data_stream:
             await data_stream.stop()
+        if trade_tasks := self.tasks.pop(_trade_id, set()):
+            await tasks_cancel(trade_tasks, _logger=logger)
+
         if self.user_session:
-            await self.user_session.stop()
+            await self.user_session.stop(_trade_id)
 
     def assert_symbol_exists(self, symbol):
-        if self.loaded and symbol not in self.symbols:
+        if symbol not in self.symbols:
             raise ExchangePyError(f"Symbol {symbol} is not valid according to the loaded exchange infos")
 
     def symbol_to_bfx(self, symbol) -> str:
@@ -261,32 +277,31 @@ class Client:
     def refine_amount(self, symbol, amount: Union[str, Decimal], _quote=False):
         if type(amount) is str:  # to save time for developers
             amount = Decimal(amount)
-        if self.loaded:
-            precision = self.symbols[symbol]["baseAssetPrecision"]
-            lot_size_filter = self.symbols[symbol]["filters"]["LOT_SIZE"]
-            step_size = Decimal(lot_size_filter["stepSize"])
-            # noinspection PyStringFormat
-            amount = (
-                (f"%.{precision}f" % truncate(amount if _quote else (amount - amount % step_size), precision))
-                .rstrip("0")
-                .rstrip(".")
-            )
+
+        precision = self.symbols[symbol]["baseAssetPrecision"]
+        lot_size_filter = self.symbols[symbol]["filters"]["LOT_SIZE"]
+        step_size = Decimal(lot_size_filter["stepSize"])
+        # noinspection PyStringFormat
+        amount = (
+            (f"%.{precision}f" % truncate(amount if _quote else (amount - amount % step_size), precision))
+            .rstrip("0")
+            .rstrip(".")
+        )
         return amount
 
     def refine_price(self, symbol, price: Union[str, Decimal]):
         if isinstance(price, str):  # to save time for developers
             price = Decimal(price)
 
-        if self.loaded:
-            precision = self.symbols[symbol]["baseAssetPrecision"]
-            price_filter = self.symbols[symbol]["filters"]["PRICE_FILTER"]
-            price = price - (price % Decimal(price_filter["tickSize"]))
-            # noinspection PyStringFormat
-            price = (
-                (f"%.{precision}f" % truncate(price, precision))
-                .rstrip("0")
-                .rstrip(".")
-            )
+        precision = self.symbols[symbol]["baseAssetPrecision"]
+        price_filter = self.symbols[symbol]["filters"]["PRICE_FILTER"]
+        price = price - (price % Decimal(price_filter["tickSize"]))
+        # noinspection PyStringFormat
+        price = (
+            (f"%.{precision}f" % truncate(price, precision))
+            .rstrip("0")
+            .rstrip(".")
+        )
         return price
 
     def assert_symbol(self, symbol):
@@ -835,7 +850,7 @@ class Client:
                     **params,
                 )
             if res:
-                timeout = STATUS_TIMEOUT / 0.1
+                timeout = int(STATUS_TIMEOUT / 0.1)
                 while not self.active_orders.get(int(res)) and timeout:
                     timeout -= 1
                     await asyncio.sleep(0.1)
@@ -908,7 +923,7 @@ class Client:
                     )
             if b_res is None:
                 fallback_warning(self.exchange, symbol)
-                b_res =  await self.http.send_api_call(
+                b_res = await self.http.send_api_call(
                     ORDER_ENDPOINT,
                     params=params,
                     signed=True,
@@ -1030,7 +1045,7 @@ class Client:
                         **params
                 )
             if res and isinstance(res, list) and res[6] == 'SUCCESS':
-                timeout = STATUS_TIMEOUT / 0.1
+                timeout = int(STATUS_TIMEOUT / 0.1)
                 while timeout:
                     timeout -= 1
                     if self.active_orders.get(order_id, {}).get('cancelled', False):
@@ -1046,7 +1061,7 @@ class Client:
                 signed=True
             )
             if res:
-                timeout = STATUS_TIMEOUT / 0.1
+                timeout = int(STATUS_TIMEOUT / 0.1)
                 while not self.active_orders.get(order_id, {}).get('cancelled', False) and timeout:
                     timeout -= 1
                     await asyncio.sleep(0.1)
@@ -1182,7 +1197,7 @@ class Client:
                         signed=True,
                         data=params,
                     )
-                ids_canceled = [int(ordr['ordId']) for ordr in res if ordr['sCode'] == '0']
+                ids_canceled = [int(order['ordId']) for order in res if order['sCode'] == '0']
                 orders_canceled[:] = [i for i in orders_canceled if i['orderId'] in ids_canceled]
                 binance_res.extend(orders_canceled)
         elif self.exchange == 'bybit':

{exchanges_wrapper-2.1.41 → exchanges_wrapper-2.1.43}/exchanges_wrapper/exch_srv.py

@@ -8,6 +8,8 @@ import grpclib.exceptions
 from exchanges_wrapper import __version__ as VER_EW
 # noinspection PyPep8Naming
 from crypto_ws_api import __version__ as VER_CW
+from crypto_ws_api.ws_session import set_logger
+
 import time
 import weakref
 import gc
@@ -16,8 +18,9 @@ import asyncio
 import functools
 # noinspection PyPackageRequirements
 import ujson as json
-import logging.handlers
+import logging
 from decimal import Decimal
+import ctypes, ctypes.util
 
 import exchanges_wrapper.martin as mr
 from exchanges_wrapper import WORK_PATH, LOG_FILE, errors, Server, Status, GRPCError, graceful_exit
@@ -29,32 +32,24 @@ from exchanges_wrapper.lib import (
     REST_RATE_LIMIT_INTERVAL,
     FILTER_TYPE_MAP,
 )
-from exchanges_wrapper.martin import StreamResponse, SimpleResponse, OnKlinesUpdateResponse, OnTickerUpdateResponse, \
-    FetchOrderBookResponse
-
+from exchanges_wrapper.martin import (
+    StreamResponse,
+    SimpleResponse,
+    OnKlinesUpdateResponse,
+    OnTickerUpdateResponse,
+    FetchOrderBookResponse,
+)
 #
 HEARTBEAT = 1  # sec
 MAX_QUEUE_SIZE = 100
 WSS_TICKER_TIMEOUT = 600  # sec
 #
-logger = logging.getLogger(__name__)
-formatter = logging.Formatter(fmt="[%(asctime)s: %(levelname)s] %(message)s")
-#
-fh = logging.handlers.RotatingFileHandler(LOG_FILE, maxBytes=1000000, backupCount=10)
-fh.setFormatter(formatter)
-fh.setLevel(logging.DEBUG)
-#
-sh = logging.StreamHandler()
-sh.setFormatter(formatter)
-sh.setLevel(logging.INFO)
-#
-root_logger = logging.getLogger()
-root_logger.setLevel(min([fh.level, sh.level]))
-root_logger.addHandler(fh)
-root_logger.addHandler(sh)
-
-logging.basicConfig()
+logger = set_logger(__name__, LOG_FILE, file_level=logging.DEBUG, set_root_logger=True)
 logging.getLogger('hpack').setLevel(logging.INFO)
+logging.getLogger('grpclib.protocol').setLevel(logging.INFO)
+
+def malloc_trim(trim_type: int = 0):
+    ctypes.CDLL(ctypes.util.find_library('c')).malloc_trim(trim_type)
 
 
 class OpenClient:
@@ -90,9 +85,9 @@ class OpenClient:
         return res
 
     @classmethod
-    def remove_client(cls, _account_name):
-        cls.open_clients[:] = [i for i in cls.open_clients if i.name != _account_name]
-
+    def remove_client(cls, _id):
+        # noinspection PyTypeHints
+        cls.open_clients[:] = [i for i in cls.open_clients if id(i) != _id]
 
 # noinspection PyPep8Naming,PyMethodMayBeStatic
 class Martin(mr.MartinBase):
@@ -139,8 +134,8 @@ class Martin(mr.MartinBase):
         try:
             await asyncio.wait_for(open_client.client.load(request.symbol), timeout=HEARTBEAT * 60)
         except asyncio.exceptions.TimeoutError:
-            await OpenClient.get_client(client_id).client.http.session.close()
-            OpenClient.remove_client(request.account_name)
+            await OpenClient.get_client(client_id).client.http.close_session()
+            OpenClient.remove_client(client_id)
             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}")
@@ -227,7 +222,7 @@ class Martin(mr.MartinBase):
         server_time = res.get('serverTime')
         return mr.FetchServerTimeResponse(server_time=server_time)
 
-    async def one_click_arrival_deposit(self, request: mr.MarketRequest) -> mr.SimpleResponse():
+    async def one_click_arrival_deposit(self, request: mr.MarketRequest) -> mr.SimpleResponse:
         res, _, _ = await self.send_request('one_click_arrival_deposit', request, tx_id=request.symbol)
         return mr.SimpleResponse(success=True, result=json.dumps(str(res)))
 
@@ -254,7 +249,7 @@ class Martin(mr.MartinBase):
 
     async def fetch_order(self, request: mr.FetchOrderRequest) -> mr.FetchOrderResponse:
         response = mr.FetchOrderResponse()
-        res, _, msg_header = await self.send_request(
+        res, client, msg_header = await self.send_request(
             'fetch_order',
             request,
             rate_limit=True,
@@ -265,14 +260,15 @@ class Martin(mr.MartinBase):
         )
         logger.debug(f"{msg_header}: {res}")
 
-        if res and request.filled_update_call and Decimal(res['executedQty']):
-            request.order_id = res['orderId']
-            await self.create_trade_stream_event(request, res)
+        if _queue := client.on_order_update_queues.get(request.trade_id):
+            if res and request.filled_update_call and Decimal(res['executedQty']):
+                request.order_id = res['orderId']
+                await self.create_trade_stream_event(request, res, _queue)
         response.from_pydict(res)
         return response
 
-    async def create_trade_stream_event(self, request, order):
-        trades, client, msg_header = await self.send_request(
+    async def create_trade_stream_event(self, request, order, _queue):
+        trades, _, msg_header = await self.send_request(
             'fetch_order_trade_list',
             request,
             trade_id=request.trade_id,
@@ -280,8 +276,6 @@ class Martin(mr.MartinBase):
             order_id=request.order_id
         )
 
-        _queue = client.on_order_update_queues.get(request.trade_id)
-
         for trade in trades:
             trade['updateTime'] = trade.pop('time')
             trade |= {
@@ -297,7 +291,7 @@ class Martin(mr.MartinBase):
             await _queue.put(weakref.ref(event)())
         logger.debug(f"{msg_header}: {trades}")
 
-    async def cancel_all_orders(self, request: mr.MarketRequest) -> mr.SimpleResponse():
+    async def cancel_all_orders(self, request: mr.MarketRequest) -> mr.SimpleResponse:
         response = mr.SimpleResponse()
 
         res, _, _ = await self.send_request(
@@ -525,10 +519,12 @@ class Martin(mr.MartinBase):
         _event_type = f"{_symbol}@miniTicker"
         client.events.register_event(functools.partial(event_handler, _queue, client, request.trade_id, _event_type),
                                      _event_type, client.exchange, request.trade_id)
+        Martin.ticker_update_time[request.trade_id] = time.time()
         while True:
             _event = await _queue.get()
             if isinstance(_event, str) and _event == request.trade_id:
                 client.stream_queue.get(request.trade_id, set()).discard(_queue)
+                Martin.ticker_update_time.pop(request.trade_id, None)
                 logger.info(f"OnTickerUpdate: Stop loop for {open_client.name}: {request.symbol}")
                 return
             else:
@@ -754,7 +750,7 @@ class Martin(mr.MartinBase):
             )
         logger.info(f"Start WS streams for {open_client.name}")
         client.start_market_events_listener(request.trade_id)
-        await client.start_user_events_listener(request.trade_id, request.symbol)
+        client.start_user_events_listener(request.trade_id, request.symbol)
         response.success = True
         return response
 
@@ -763,37 +759,43 @@ class Martin(mr.MartinBase):
         if open_client := OpenClient.get_client(request.client_id):
             client = open_client.client
             logger.info(f"StopStream request for {request.symbol} on {client.exchange}")
-            await stop_stream(client, request.trade_id)
+            await stop_stream_ex(client, request.trade_id)
             response.success = True
         else:
             response.success = False
         return response
 
     async def check_stream(self, request: mr.MarketRequest) -> mr.SimpleResponse:
-        response = mr.SimpleResponse()
-        check_time = time.time() - Martin.ticker_update_time.get(request.trade_id, time.time() - WSS_TICKER_TIMEOUT - 1)
-        if check_time < WSS_TICKER_TIMEOUT:
-            response.success = True
-        else:
-            response.success = False
+        last_update = Martin.ticker_update_time.get(request.trade_id, 0)
+        check_time = time.time() - last_update
+        success = check_time < WSS_TICKER_TIMEOUT
+        response = mr.SimpleResponse(success=success)
+        if not success:
+            Martin.ticker_update_time.pop(request.trade_id, None)
             logger.warning(f"CheckStream request failed for {request.trade_id}")
         return response
 
     async def client_restart(self, request: mr.MarketRequest) -> mr.SimpleResponse:
-        if session := OpenClient.get_client(request.client_id).client.http.session:
-            await session.close()
-        OpenClient.remove_client(request.account_name)
+        await self.stop_stream(request)
+        if client := OpenClient.get_client(request.client_id).client:
+            if user_session := client.user_session:
+                await user_session.stop(request.trade_id)
+            if session := client.http:
+                await session.close_session()
+        OpenClient.remove_client(request.client_id)
         return mr.SimpleResponse(success=True)
 
 
-async def stop_stream(client, trade_id):
+async def stop_stream_ex(client, trade_id):
     await client.stop_events_listener(trade_id)
     client.events.unregister(client.exchange, trade_id)
     [await _queue.put(trade_id) for _queue in client.stream_queue.get(trade_id, [])]
     await asyncio.sleep(0)
     client.on_order_update_queues.pop(trade_id, None)
     client.stream_queue.pop(trade_id, None)
+    Martin.ticker_update_time.pop(trade_id, None)
     gc.collect(generation=2)
+    malloc_trim()
 
 
 async def event_handler(_queue, client, trade_id, _event_type, event):
@@ -802,10 +804,7 @@ async def event_handler(_queue, client, trade_id, _event_type, event):
     except asyncio.QueueFull:
         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}")
+        await stop_stream_ex(client, trade_id)
 
 
 def is_port_in_use(port: int) -> bool:
@@ -825,8 +824,8 @@ async def amain(host: str = '127.0.0.1', port: int = 50051):
         await server.wait_closed()
 
         for oc in OpenClient.open_clients:
-            if oc.client.http.session:
-                await oc.client.http.session.close()
+            if oc.client.http:
+                await oc.client.http.close_session()
 
         [task.cancel() for task in asyncio.all_tasks() if not task.done() and task is not asyncio.current_task()]
 
@@ -836,8 +835,8 @@ def main():
         asyncio.run(amain())
     except grpclib.exceptions.StreamTerminatedError:
         pass  # Task cancellation should not be logged as an error
-    except Exception as ex:
-        print(f"Exception: {ex}")
+    except Exception as expt:
+        print(f"Exception: {expt}")
         print(traceback.format_exc())
 
 

{exchanges_wrapper-2.1.41 → exchanges_wrapper-2.1.43}/exchanges_wrapper/http_client.py

@@ -29,6 +29,21 @@ ERR_TIMESTAMP_OUTSIDE_RECV_WINDOW = "Timestamp for this request is outside of th
 TIMEOUT = aiohttp.ClientTimeout(total=60)
 
 class HttpClient:
+    __slots__ = (
+        'api_key',
+        'api_secret',
+        'passphrase',
+        'endpoint',
+        'exchange',
+        'test_net',
+        'rate_limit_reached',
+        'rest_cycle_lock',
+        'session',
+        '_session_mutex',
+        'ex_imps',
+        'rate_limit_handler'
+    )
+
     def __init__(self, params: dict):
         self.api_key = params['api_key']
         self.api_secret = params['api_secret']
@@ -54,10 +69,15 @@ class HttpClient:
         }
 
     async def _create_session_if_required(self):
-        if self.session is None or self.session.closed:
+        if not self.session:
             async with self._session_mutex:
                 self.session = aiohttp.ClientSession(trust_env=True, timeout=TIMEOUT)
 
+    async def close_session(self):
+        if self.session:
+            await self.session.close()
+            self.session = None
+
     async def handle_errors(self, response, path=None):
         if response.status >= 500:
             raise ExchangeError(
@@ -141,13 +161,12 @@ class HttpClient:
         await self._create_session_if_required()
         try:
             async with self.session.request(method, url, timeout=timeout, **query_kwargs) as response:
-
                 if self.exchange == 'bybit':
                     self.rate_limit_handler.update(path, response.headers)
 
                 return await self.handle_errors(response, path)
         except (aiohttp.ClientConnectionError, asyncio.exceptions.TimeoutError):
-            await self.session.close()
+            await self.close_session()
             raise ExchangeError("HTTP ClientConnectionError, the connection will be restored")
 
     async def _binance_request(self, path, method, signed, send_api_key, endpoint, timeout, **kwargs):

{exchanges_wrapper-2.1.41 → exchanges_wrapper-2.1.43}/exchanges_wrapper/lib.py

@@ -25,7 +25,7 @@ FILTER_TYPE_MAP = {
 
 
 class OrderTradesEvent:
-    def __init__(self, event_data: {}):
+    def __init__(self, event_data: dict):
         self.symbol = event_data["symbol"]
         self.client_order_id = event_data["clientOrderId"]
         self.side = "BUY" if event_data["isBuyer"] else "SELL"

{exchanges_wrapper-2.1.41 → exchanges_wrapper-2.1.43}/exchanges_wrapper/parsers/okx.py

@@ -15,7 +15,7 @@ def fetch_server_time(res: list) -> dict | None:
     return None
 
 
-def exchange_info(server_time: int, trading_symbol: list, tickers: list, symbol_t) -> {}:
+def exchange_info(server_time: int, trading_symbol: list, tickers: list, symbol_t) -> dict:
     symbols = []
     symbols_price = {}
     for pair in tickers:
@@ -98,7 +98,7 @@ def orders(res: list, response_type=None) -> list:
     return binance_orders
 
 
-def order(res: {}, response_type=None) -> {}:
+def order(res: dict, response_type=None) -> dict:
     symbol = res.get('instId').replace('-', '')
     order_id = int(res.get('ordId'))
     order_list_id = -1
@@ -186,7 +186,7 @@ def order(res: {}, response_type=None) -> {}:
         }
 
 
-def place_order_response(res: {}, req: {}) -> {}:
+def place_order_response(res: dict, req: dict) -> dict:
     return {
         "symbol": req["instId"].replace('-', ''),
         "orderId": int(res["ordId"]),
@@ -230,7 +230,7 @@ def order_book(res: dict) -> Dict[str, Union[int, List[List[str]]]]:
     return binance_order_book
 
 
-def ticker_price_change_statistics(res: {}) -> {}:
+def ticker_price_change_statistics(res: dict) -> dict:
     price_change = str(Decimal(res.get('last')) - Decimal(res.get('open24h')))
     price_change_percent = str(100 * (Decimal(res.get('last')) - Decimal(res.get('open24h'))) /
                                Decimal(res.get('open24h')))
@@ -263,14 +263,14 @@ def ticker_price_change_statistics(res: {}) -> {}:
     }
 
 
-def fetch_symbol_price_ticker(res: {}, symbol) -> {}:
+def fetch_symbol_price_ticker(res: dict, symbol) -> dict:
     return {
         "symbol": symbol,
         "price": res.get('last')
     }
 
 
-def ticker(res: {}) -> {}:
+def ticker(res: dict) -> dict:
     symbol = res.get('instId').replace('-', '')
     return {
         'stream': f"{symbol.lower()}@miniTicker",
@@ -344,7 +344,7 @@ def interval2value(_interval: str) -> int:
     return resolution.get(_interval, 0)
 
 
-def candle(res: list, symbol: str = None, ch_type: str = None) -> {}:
+def candle(res: list, symbol: str = None, ch_type: str = None) -> dict:
     symbol = symbol.replace('-', '').lower()
     start_time = int(res[0])
     _interval = ch_type.replace('kline_', '')
@@ -378,7 +378,7 @@ def candle(res: list, symbol: str = None, ch_type: str = None) -> {}:
     }
 
 
-def order_book_ws(res: {}, symbol: str) -> {}:
+def order_book_ws(res: dict, symbol: str) -> dict:
     symbol = symbol.replace('-', '').lower()
     return {
         'stream': f"{symbol}@depth5",
@@ -386,7 +386,7 @@ def order_book_ws(res: {}, symbol: str) -> {}:
     }
 
 
-def on_funds_update(res: {}) -> {}:
+def on_funds_update(res: dict) -> dict:
     event_time = int(time.time() * 1000)
     data = res.get('details')
     funds = []
@@ -408,7 +408,7 @@ def on_funds_update(res: {}) -> {}:
     }
 
 
-def on_order_update(res: {}) -> {}:
+def on_order_update(res: dict) -> dict:
     # print(f"on_order_update.res: {res}")
     order_quantity = res.get('sz')
     order_price = res.get('px')
@@ -464,7 +464,7 @@ def on_order_update(res: {}) -> {}:
     }
 
 
-def on_balance_update(res: list, buffer: dict, transfer: bool) -> ():
+def on_balance_update(res: list, buffer: dict, transfer: bool) -> tuple:
     res_diff = []
     for i in res:
         asset = i.get('ccy')

{exchanges_wrapper-2.1.41 → exchanges_wrapper-2.1.43}/exchanges_wrapper/web_sockets.py

@@ -1,8 +1,10 @@
 import sys
 import asyncio
+import gc
+import logging
+
 # noinspection PyPackageRequirements
 import ujson as json
-import logging.handlers
 from pathlib import Path
 import time
 from decimal import Decimal
@@ -18,28 +20,36 @@ import exchanges_wrapper.parsers.bitfinex as bfx
 import exchanges_wrapper.parsers.huobi as hbp
 import exchanges_wrapper.parsers.okx as okx
 import exchanges_wrapper.parsers.bybit as bbt
-from crypto_ws_api.ws_session import generate_signature, compose_htx_ws_auth, compose_binance_ws_auth
-from exchanges_wrapper import LOG_PATH
-
-logger = logging.getLogger(__name__)
-formatter = logging.Formatter(fmt="[%(asctime)s: %(levelname)s] %(message)s")
-#
-fh = logging.handlers.RotatingFileHandler(Path(LOG_PATH, 'websockets.log'), maxBytes=1000000, backupCount=10)
-fh.setFormatter(formatter)
-fh.setLevel(logging.INFO)
-#
-sh = logging.StreamHandler()
-sh.setFormatter(formatter)
-sh.setLevel(logging.INFO)
-
-logger.addHandler(fh)
-logger.addHandler(sh)
-logger.propagate = False
-
+from crypto_ws_api.ws_session import (
+    set_logger,
+    generate_signature,
+    compose_htx_ws_auth,
+    compose_binance_ws_auth,
+    tasks_manage,
+    tasks_cancel
+)
+from exchanges_wrapper import LOG_PATH, DEBUG_LOG
+
+logger = set_logger(__name__, Path(LOG_PATH, 'websockets.log'))
 sys.tracebacklimit = 0
 
 
 class EventsDataStream:
+    __slots__ = (
+        'client',
+        'endpoint',
+        'exchange',
+        'trade_id',
+        'websocket',
+        'try_count',
+        'wss_event_buffer',
+        '_order_book',
+        '_price',
+        'tasks',
+        'ping',
+        'logger'
+    )
+
     def __init__(self, client, endpoint, exchange, trade_id):
         self.client = client
         self.endpoint = endpoint
@@ -51,51 +61,54 @@ class EventsDataStream:
         self._order_book = None
         self._price = None
         self.tasks = set()
-        self.wss_started = False
         self.ping = 0
+        self.logger = logger
+
+        if exchange == DEBUG_LOG:
+            log_key = f"web_s_{trade_id}"
+            if log_key in logging.root.manager.loggerDict:
+                self.logger = logging.root.manager.loggerDict[log_key]
+            else:
+                self.logger = set_logger(log_key, Path(LOG_PATH, f"{log_key}.log"), logging.DEBUG)
 
     async def start(self):
         async for self.websocket in connect(
                 self.endpoint,
-                logger=logger,
+                logger=self.logger,
                 ping_interval=None if self.exchange in ('binance', 'huobi') else 20
         ):
+            await self.cycle_init()
             start_time = datetime.now(timezone.utc).replace(tzinfo=None)
             try:
                 await self.start_wss()
             except ConnectionClosed as ex:
+                self.websocket = None
                 ct = str(datetime.now(timezone.utc).replace(tzinfo=None) - start_time).rsplit('.')[0]
-                logger.info(f"WSS life time for {self.exchange} is {ct}")
-                self.tasks_cancel()
+                self.logger.info(f"WSS life time for {self.exchange}:{self.trade_id} is {ct}")
                 if ex.rcvd and ex.rcvd.code == 4000:
-                    logger.info(f"WSS closed for {self.exchange}:{self.trade_id}")
+                    self.logger.info(f"WSS closed for {self.exchange}:{self.trade_id}")
                     break
                 else:
-                    logger.warning(f"Restart WSS for {self.exchange}: {ex}")
+                    self.logger.warning(f"Restart WSS for {self.exchange}: {ex}")
                     continue
             except Exception as ex:
-                self.tasks_cancel()
-                logger.error(f"WSS start() other exception: {ex}")
+                self.logger.error(f"WSS start() other exception: {ex}")
 
     async def start_wss(self):
         pass  # meant to be overridden in a subclass
 
+    async def cycle_init(self):
+        await tasks_cancel(self.tasks, _logger=logger)
+        self.wss_event_buffer.clear()
+        gc.collect()
+
     async def stop(self):
         """
         Stop data stream
         """
-        self.tasks_cancel()
         if self.websocket:
             await self.websocket.close(code=4000)
-
-    def tasks_cancel(self):
-        [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)
+        await self.cycle_init()
 
     async def _handle_event(self, *args):
         pass  # meant to be overridden in a subclass
@@ -109,8 +122,11 @@ class EventsDataStream:
                 await self._handle_event(event)
             elif msg_data.get("status") == 200:
                 result = msg_data.get("result")
-                if isinstance(result, dict) and not result:
-                    self.wss_started = True
+                if isinstance(result, dict) and 'authorizedSince' in result:
+                    self.logger.info(f"Binance User Data Stream started for {self.trade_id}")
+            else:
+                self.logger.warning(f"Reconnecting Binance User Data Stream for {self.trade_id}, msg_data: {msg_data}")
+                raise ConnectionClosed(None, None)
         elif self.exchange == 'bybit':
             if _data := msg_data.get('data'):
                 if ch_type == 'depth5':
@@ -127,15 +143,17 @@ class EventsDataStream:
                 return
             elif ((msg_data.get("ret_msg") == "subscribe" or msg_data.get("op") in ("auth", "subscribe"))
                   and msg_data.get("success")):
-                self.tasks_manage(self.bybit_heartbeat(ch_type or "private"))
+                tasks_manage(
+                    self.tasks, self.bybit_heartbeat(ch_type or "private"), f"bybit_heartbeat-{symbol}-{ch_type}"
+                )
                 if msg_data["op"] == "subscribe" and msg_data["success"] and not msg_data["ret_msg"]:
-                    self.wss_started = True
+                    self.logger.info(f"ByBit User Data Stream started for {self.trade_id}")
             elif ((msg_data.get("ret_msg") == "subscribe" or msg_data.get("op") in ("auth", "subscribe"))
                   and not msg_data.get("success")):
-                logger.warning(f"Reconnecting ByBit WSS: {symbol}: {ch_type}, msg_data: {msg_data}")
+                self.logger.warning(f"Reconnecting ByBit WSS: {symbol}: {ch_type}, msg_data: {msg_data}")
                 raise ConnectionClosed(None, None)
             else:
-                logger.info(f"ByBit undefined WSS: symbol: {symbol}, ch_type: {ch_type}, msg_data: {msg_data}")
+                self.logger.info(f"ByBit undefined WSS: symbol: {symbol}, ch_type: {ch_type}, msg_data: {msg_data}")
         elif self.exchange == 'okx':
             if (not ch_type and
                     msg_data.get('arg', {}).get('channel') in ('account', 'orders', 'balance_and_position')
@@ -146,46 +164,45 @@ class EventsDataStream:
             elif msg_data.get("event") == "login" and msg_data.get("code") == "0":
                 return
             elif msg_data.get("event") == "subscribe" and msg_data.get('arg', {}).get('channel') == 'orders':
-                self.wss_started = True
+                self.logger.info(f"OKX User Data Stream started for {self.trade_id}")
             elif msg_data.get("event") in ("login", "error") and msg_data.get("code") != "0":
-                logger.warning(f"Reconnecting OKX WSS: {symbol}: {ch_type}, msg_data: {msg_data}")
+                self.logger.warning(f"Reconnecting OKX WSS: {symbol}: {ch_type}, msg_data: {msg_data}")
                 raise ConnectionClosed(None, None)
             else:
-                logger.debug(f"OKX undefined WSS: symbol: {symbol}, ch_type: {ch_type}, msg_data: {msg_data}")
+                self.logger.debug(f"OKX undefined WSS: symbol: {symbol}, ch_type: {ch_type}, msg_data: {msg_data}")
         elif self.exchange == 'bitfinex':
             # info and error handling
             if isinstance(msg_data, dict):
                 if msg_data.get('version') and msg_data.get('version') != 2:
-                    logger.critical('Change WSS version detected')
+                    self.logger.critical('Change WSS version detected')
                 if msg_data.get('platform') and msg_data.get('platform').get('status') != 1:
-                    logger.warning(f"Exchange in maintenance mode, trying reconnect. Exchange info: {msg}")
+                    self.logger.warning(f"Exchange in maintenance mode, trying reconnect. Exchange info: {msg}")
                     await asyncio.sleep(60)
                     raise ConnectionClosed(None, None)
                 elif 'code' in msg_data:
                     code = msg_data.get('code')
                     if code == 10300:
-                        logger.warning('WSS Subscription failed (generic)')
+                        self.logger.warning('WSS Subscription failed (generic)')
                         raise ConnectionClosed(None, None)
                     elif code == 10301:
-                        logger.error('WSS Already subscribed')
+                        self.logger.error('WSS Already subscribed')
                     elif code == 10302:
                         raise UserWarning(f"WSS Unknown channel {ch_type}")
                     elif code == 10305:
                         raise UserWarning('WSS Reached limit of open channels')
                     elif code == 20051:
-                        logger.warning('WSS reconnection request received from exchange')
+                        self.logger.warning('WSS reconnection request received from exchange')
                         raise ConnectionClosed(None, None)
                     elif code == 20060:
-                        logger.info('WSS entering in maintenance mode, trying reconnect after 120s')
+                        self.logger.info('WSS entering in maintenance mode, trying reconnect after 120s')
                         await asyncio.sleep(120)
                         raise ConnectionClosed(None, None)
                 elif msg_data.get('event') == 'subscribed':
                     chan_id = msg_data.get('chanId')
-                    logger.info(f"bitfinex, ch_type: {ch_type}, chan_id: {chan_id}")
+                    self.logger.info(f"bitfinex, ch_type: {ch_type}, chan_id: {chan_id}")
                 elif msg_data.get('event') == 'auth' and msg_data.get('status') == 'OK':
                     chan_id = msg_data.get('chanId')
-                    self.wss_started = True
-                    logger.info(f"bitfinex, user stream chan_id: {chan_id}")
+                    self.logger.info(f"Bitfinex, user stream chan_id: {chan_id}")
 
             # data handling
             elif isinstance(msg_data, list) and len(msg_data) == 2 and msg_data[1] == 'hb':
@@ -196,7 +213,7 @@ class EventsDataStream:
                 else:
                     await self._handle_event(msg_data, symbol, ch_type)
             else:
-                logger.debug(f"Bitfinex undefined WSS: symbol: {symbol}, ch_type: {ch_type}, msg_data: {msg_data}")
+                self.logger.debug(f"Bitfinex undefined WSS: symbol: {symbol}, ch_type: {ch_type}, msg_data: {msg_data}")
         elif self.exchange == 'huobi':
             if ping := msg_data.get('ping'):
                 self.ping = 0
@@ -222,16 +239,16 @@ class EventsDataStream:
                     await self._handle_event(msg_data, symbol, ch_type)
             elif msg_data.get('action') in ('req', 'sub') and msg_data.get('code') == 200:
                 if msg_data.get('ch') == f"trade.clearing#{symbol.lower()}#0":
-                    self.wss_started = True
+                    self.logger.info(f"HTX User Data Stream started for {self.trade_id}")
             elif 'subbed' in msg_data and msg_data.get('status') == 'ok':
-                logger.info(f"Huobi WSS started: {msg_data['subbed']}")
+                self.logger.info(f"Huobi WSS started: {msg_data['subbed']}")
             elif (msg_data.get('action') == 'sub' and
                   msg_data.get('code') == 500 and
                   msg_data.get('message') == '系统异常:'):
-                logger.warning(f"Reconnecting Huobi user {ch_type} channel")
+                self.logger.warning(f"Reconnecting Huobi user {ch_type} channel")
                 raise ConnectionClosed(None, None)
             else:
-                logger.debug(f"Huobi undefined WSS: symbol: {symbol}, ch_type: {ch_type}, msg_data: {msg_data}")
+                self.logger.debug(f"Huobi undefined WSS: symbol: {symbol}, ch_type: {ch_type}, msg_data: {msg_data}")
 
     async def ws_listener(self, request=None, symbol=None, ch_type=str()):
         if request:
@@ -245,22 +262,25 @@ class EventsDataStream:
             await asyncio.sleep(interval)
             try:
                 await self.websocket.send(json.dumps({"req_id": req_id, "op": "ping"}))
-            except (ConnectionClosed, asyncio.exceptions.TimeoutError):
-                pass  # handled elsewhere
+            except (ConnectionClosed, asyncio.exceptions.TimeoutError, AttributeError):
+                break
 
     async def htx_keepalive(self, interval=60):
-        await asyncio.sleep(interval * 10)
+        await asyncio.sleep(interval)
         while True:
             await asyncio.sleep(interval)
             if self.ping:
                 break
             else:
                 self.ping = 1
-        logger.warning("From HTX server PING timeout exceeded")
-        await self.websocket.close()
+        self.logger.warning("From HTX server PING timeout exceeded")
+        if self.websocket:
+            await self.websocket.close()
 
 
 class MarketEventsDataStream(EventsDataStream):
+    __slots__ = ('channel', 'candles_max_time', 'endpoint')
+
     def __init__(self, client, endpoint, exchange, trade_id, channel=None):
         super().__init__(client, endpoint, exchange, trade_id)
         self.channel = channel
@@ -271,7 +291,7 @@ class MarketEventsDataStream(EventsDataStream):
             self.endpoint = f"{endpoint}/stream?streams={combined_streams}"
 
     async def start_wss(self):
-        logger.info(f"Start market WSS {self.channel or ''} for {self.exchange}")
+        self.logger.info(f"Start market WSS {self.channel or ''} for {self.exchange}")
         symbol = None
         ch_type = str()
         request = {}
@@ -330,12 +350,12 @@ class MarketEventsDataStream(EventsDataStream):
                 elif ch_type == 'depth5':
                     request = {'sub': f"market.{symbol}.depth.step0"}
 
-                self.tasks_manage(self.htx_keepalive(interval=30))
+                tasks_manage(self.tasks, self.htx_keepalive(interval=30), f"htx_keepalive-{symbol}-{ch_type}")
 
         await self.ws_listener(request, symbol, ch_type)
 
     async def _handle_event(self, content, symbol=None, ch_type=str()):
-        # logger.info(f"MARKET_handle_event.content: symbol: {symbol}, ch_type: {ch_type}, content: {content}")
+        # self.logger.info(f"MARKET_handle_event.content: symbol: {symbol}, ch_type: {ch_type}, content: {content}")
         self.try_count = 0
         if self.exchange == 'bitfinex':
             if 'candles' in ch_type:
@@ -390,6 +410,8 @@ class MarketEventsDataStream(EventsDataStream):
 
 
 class HbpPrivateEventsDataStream(EventsDataStream):
+    __slots__ = ('symbol',)
+
     def __init__(self, client, endpoint, exchange, trade_id, symbol):
         super().__init__(client, endpoint, exchange, trade_id)
         self.symbol = symbol
@@ -423,7 +445,7 @@ class HbpPrivateEventsDataStream(EventsDataStream):
             "action": "sub",
             "ch": f"trade.clearing#{self.symbol.lower()}#0"
         }
-        self.tasks_manage(self.htx_keepalive())
+        tasks_manage(self.tasks, self.htx_keepalive(), f"htx_keepalive-user-{self.symbol}")
         await self.ws_listener(request, symbol=self.symbol)
 
     async def _handle_event(self, msg_data, *args):
@@ -446,11 +468,12 @@ class HbpPrivateEventsDataStream(EventsDataStream):
                 content = hbp.on_order_update(self.client.active_orders[order_id])
 
         if content:
-            logger.debug(f"HTXPrivateEvents.content: {content}")
+            self.logger.debug(f"HTXPrivateEvents.content: {content}")
             await self.client.events.wrap_event(content).fire(self.trade_id)
 
 
 class BfxPrivateEventsDataStream(EventsDataStream):
+    __slots__ = ()
 
     async def start_wss(self):
         ts = int(time.time() * 1000)
@@ -505,6 +528,8 @@ class BfxPrivateEventsDataStream(EventsDataStream):
 
 
 class OkxPrivateEventsDataStream(EventsDataStream):
+    __slots__ = ('symbol',)
+
     def __init__(self, client, endpoint, exchange, trade_id, symbol):
         super().__init__(client, endpoint, exchange, trade_id)
         self.symbol = symbol
@@ -561,6 +586,7 @@ class OkxPrivateEventsDataStream(EventsDataStream):
 
 
 class BBTPrivateEventsDataStream(EventsDataStream):
+    __slots__ = ()
 
     async def start_wss(self):
         ts = int((time.time() + 1) * 1000)
@@ -591,7 +617,7 @@ class BBTPrivateEventsDataStream(EventsDataStream):
                 await self.client.events.wrap_event(content).fire(self.trade_id)
             content = None
         elif ch_type == 'order.spot':
-            # logger.info(f"_handle_event: ch_type: {ch_type}, msg_data: {msg_data}")
+            # self.logger.info(f"_handle_event: ch_type: {ch_type}, msg_data: {msg_data}")
             event = msg_data[0]
             if event.get('orderStatus') in ("Cancelled", "PartiallyFilledCanceled"):
                 self.client.wss_buffer[f"oc-{event.get('orderId')}"] = bbt.order(event, response_type=True)
@@ -603,6 +629,7 @@ class BBTPrivateEventsDataStream(EventsDataStream):
 
 
 class UserEventsDataStream(EventsDataStream):
+    __slots__ = ()
 
     async def start_wss(self):
         await self.websocket.send(
@@ -620,5 +647,5 @@ class UserEventsDataStream(EventsDataStream):
         await self.ws_listener(request)
 
     async def _handle_event(self, content):
-        # logger.debug(f"UserEventsDataStream._handle_event.content: {content}")
+        # self.logger.debug(f"UserEventsDataStream._handle_event.content: {content}")
         await self.client.events.wrap_event(content).fire(self.trade_id)

{exchanges_wrapper-2.1.41 → exchanges_wrapper-2.1.43}/pyproject.toml

@@ -4,7 +4,10 @@ build-backend = "flit_core.buildapi"
 
 [project]
 name = "exchanges-wrapper"
-authors = [{name = "Thomas Marchand", email = "thomas.marchand@tuta.io"}, {name = "Jerry Fedorenko", email = "jerry.fedorenko@yahoo.com"}]
+authors = [
+    {name = "Thomas Marchand", email = "thomas.marchand@tuta.io"},
+    {name = "Jerry Fedorenko", email = "jerry.fedorenko@yahoo.com"}
+]
 readme = "README.md"
 license = {file = "LICENSE.md"}
 classifiers=["Programming Language :: Python :: 3",
@@ -17,10 +20,10 @@ dynamic = ["version", "description"]
 requires-python = ">=3.10"
 
 dependencies = [
-    "crypto-ws-api==2.1.0",
+    "crypto-ws-api==2.1.4",
     "pyotp==2.9.0",
-    "simplejson==3.20.1",
-    "aiohttp~=3.12.13",
+    "simplejson==3.20.2",
+    "aiohttp~=3.13.2",
     "expiringdict~=1.2.2",
     "betterproto==2.0.0b7",
     "grpclib~=0.4.8"