exchanges-wrapper 2.1.40__tar.gz → 2.1.42__tar.gz

{exchanges_wrapper-2.1.40 → exchanges_wrapper-2.1.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: exchanges-wrapper
-Version: 2.1.40
+Version: 2.1.42
 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.0.20
+Requires-Dist: crypto-ws-api==2.1.3
 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.0
 Requires-Dist: expiringdict~=1.2.2
 Requires-Dist: betterproto==2.0.0b7
 Requires-Dist: grpclib~=0.4.8
@@ -28,12 +28,15 @@ Project-URL: Source, https://github.com/DogsTailFarmer/exchanges-wrapper
 <h3 align="center">For SPOT markets</h3>
 
 ***
-<a href="https://pypi.org/project/exchanges-wrapper/"><img src="https://img.shields.io/pypi/v/exchanges-wrapper" alt="PyPI version"></a>
+<h1 align="center"><a href="https://pypi.org/project/exchanges-wrapper/"><img src="https://img.shields.io/pypi/v/exchanges-wrapper" alt="PyPI version"></a>
 <a href="https://deepsource.io/gh/DogsTailFarmer/exchanges-wrapper/?ref=repository-badge}" target="_blank"><img alt="DeepSource" title="DeepSource" src="https://deepsource.io/gh/DogsTailFarmer/exchanges-wrapper.svg/?label=resolved+issues&token=XuG5PmzMiKlDL921-qREIuX_"/></a>
 <a href="https://deepsource.io/gh/DogsTailFarmer/exchanges-wrapper/?ref=repository-badge}" target="_blank"><img alt="DeepSource" title="DeepSource" src="https://deepsource.io/gh/DogsTailFarmer/exchanges-wrapper.svg/?label=active+issues&token=XuG5PmzMiKlDL921-qREIuX_"/></a>
 <a href="https://sonarcloud.io/summary/new_code?id=DogsTailFarmer_exchanges-wrapper" target="_blank"><img alt="sonarcloud" title="sonarcloud" src="https://sonarcloud.io/api/project_badges/measure?project=DogsTailFarmer_exchanges-wrapper&metric=alert_status"/></a>
 <a href="https://pepy.tech/project/exchanges-wrapper" target="_blank"><img alt="Downloads" title="Downloads" src="https://static.pepy.tech/badge/exchanges-wrapper/month"/></a>
+</h1>
+
 ***
+
 On `Binance`: now API key type [Ed25519](https://www.binance.com/en/support/faq/detail/6b9a63f1e3384cf48a2eedb82767a69a) is used instead of `HMAC`
 
 From `2.1.34` must be updated `exch_srv_cfg.toml` from `exchanges_wrapper/exch_srv_cfg.toml.template`

{exchanges_wrapper-2.1.40 → exchanges_wrapper-2.1.42}/README.md

@@ -5,12 +5,15 @@
 <h3 align="center">For SPOT markets</h3>
 
 ***
-<a href="https://pypi.org/project/exchanges-wrapper/"><img src="https://img.shields.io/pypi/v/exchanges-wrapper" alt="PyPI version"></a>
+<h1 align="center"><a href="https://pypi.org/project/exchanges-wrapper/"><img src="https://img.shields.io/pypi/v/exchanges-wrapper" alt="PyPI version"></a>
 <a href="https://deepsource.io/gh/DogsTailFarmer/exchanges-wrapper/?ref=repository-badge}" target="_blank"><img alt="DeepSource" title="DeepSource" src="https://deepsource.io/gh/DogsTailFarmer/exchanges-wrapper.svg/?label=resolved+issues&token=XuG5PmzMiKlDL921-qREIuX_"/></a>
 <a href="https://deepsource.io/gh/DogsTailFarmer/exchanges-wrapper/?ref=repository-badge}" target="_blank"><img alt="DeepSource" title="DeepSource" src="https://deepsource.io/gh/DogsTailFarmer/exchanges-wrapper.svg/?label=active+issues&token=XuG5PmzMiKlDL921-qREIuX_"/></a>
 <a href="https://sonarcloud.io/summary/new_code?id=DogsTailFarmer_exchanges-wrapper" target="_blank"><img alt="sonarcloud" title="sonarcloud" src="https://sonarcloud.io/api/project_badges/measure?project=DogsTailFarmer_exchanges-wrapper&metric=alert_status"/></a>
 <a href="https://pepy.tech/project/exchanges-wrapper" target="_blank"><img alt="Downloads" title="Downloads" src="https://static.pepy.tech/badge/exchanges-wrapper/month"/></a>
+</h1>
+
 ***
+
 On `Binance`: now API key type [Ed25519](https://www.binance.com/en/support/faq/detail/6b9a63f1e3384cf48a2eedb82767a69a) is used instead of `HMAC`
 
 From `2.1.34` must be updated `exch_srv_cfg.toml` from `exchanges_wrapper/exch_srv_cfg.toml.template`

{exchanges_wrapper-2.1.40 → exchanges_wrapper-2.1.42}/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.40"
+__version__ = "2.1.42"
 
 from pathlib import Path
 import shutil
@@ -23,9 +23,21 @@ from grpclib.utils import graceful_exit
 from grpclib import exceptions
 
 __all__ = [
-    'Server', 'GRPCError', 'Status', 'Channel', 'graceful_exit', 'exceptions'
+    '__version__',
+    'Server',
+    'GRPCError',
+    'Status',
+    'Channel',
+    'graceful_exit',
+    'exceptions',
+    'LOG_PATH',
+    'WORK_PATH',
+    'LOG_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.40 → exchanges_wrapper-2.1.42}/exchanges_wrapper/client.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import Union
+from typing import Union, Dict
 import decimal
 import math
 import asyncio
@@ -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', 'loaded', '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']
@@ -98,15 +113,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:
@@ -144,8 +154,8 @@ class Client:
         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 +164,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 +182,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,15 +212,21 @@ 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:
@@ -587,7 +605,7 @@ class Client:
                 "/api/v3/klines", params=params, signed=False
             )
         elif self.exchange == 'bitfinex':
-            params = {'limit': limit, 'sort': -1}
+            params: Dict[str, Union[str, int]] = {'limit': limit, 'sort': -1}
             if start_time:
                 params["start"] = str(start_time)
             if end_time:
@@ -835,7 +853,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 +926,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 +1048,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 +1064,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 +1200,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.40 → exchanges_wrapper-2.1.42}/exchanges_wrapper/exch_srv.py

@@ -4,7 +4,9 @@ from typing import Any, AsyncGenerator
 
 import grpclib.exceptions
 
+# noinspection PyPep8Naming
 from exchanges_wrapper import __version__ as VER_EW
+# noinspection PyPep8Naming
 from crypto_ws_api import __version__ as VER_CW
 import time
 import weakref
@@ -27,9 +29,13 @@ 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
@@ -136,10 +142,8 @@ class Martin(mr.MartinBase):
 
         try:
             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.http.session.close()
+            await OpenClient.get_client(client_id).client.http.close_session()
             OpenClient.remove_client(request.account_name)
             raise GRPCError(status=Status.UNAVAILABLE, message=f"'{open_client.name}' timeout error")
         except Exception as ex:
@@ -186,7 +190,7 @@ class Martin(mr.MartinBase):
 
         try:
             res = await asyncio.wait_for(getattr(client, client_method_name)(**kwargs), timeout=90)
-        except asyncio.exceptions.CancelledError:
+        except KeyboardInterrupt:
             raise GRPCError(status=Status.UNAVAILABLE, message=f"{msg_header} Server Shutdown")
         except asyncio.exceptions.TimeoutError:
             self.log_and_raise_grpc_error(msg_header, Status.DEADLINE_EXCEEDED, "timeout error")
@@ -227,7 +231,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)))
 
@@ -297,7 +301,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(
@@ -754,7 +758,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,7 +767,7 @@ 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
@@ -780,13 +784,13 @@ class Martin(mr.MartinBase):
         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()
+        if session := OpenClient.get_client(request.client_id).client.http:
+            await session.close_session()
         OpenClient.remove_client(request.account_name)
         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, [])]
@@ -802,10 +806,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 +826,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()]
 
@@ -834,12 +835,11 @@ async def amain(host: str = '127.0.0.1', port: int = 50051):
 def main():
     try:
         asyncio.run(amain())
-    except (asyncio.exceptions.CancelledError, grpclib.exceptions.StreamTerminatedError):
+    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())
 
-
 if __name__ == '__main__':
     main()

{exchanges_wrapper-2.1.40 → exchanges_wrapper-2.1.42}/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,9 +69,14 @@ 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(timeout=TIMEOUT)
+                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:
@@ -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):
@@ -170,7 +189,7 @@ class HttpClient:
     async def _bitfinex_request(self, path, method, signed, send_api_key, endpoint, timeout, **kwargs):
         _endpoint = endpoint or self.endpoint
         bfx_post = (method == 'POST' and kwargs) or "params" in kwargs
-        _params = json.dumps(kwargs) if bfx_post else None
+        _params = json.dumps(kwargs) if bfx_post else {}
         url = f'{_endpoint}/{path}'
         query_kwargs = {"headers": {"Accept": AJ}}
         if kwargs and not bfx_post:

{exchanges_wrapper-2.1.40 → exchanges_wrapper-2.1.42}/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.40 → exchanges_wrapper-2.1.42}/exchanges_wrapper/parsers/bitfinex.py

@@ -4,6 +4,7 @@ Parser for convert Bitfinex REST API/WSS response to Binance like result
 import time
 from decimal import Decimal
 import logging
+from typing import Dict, List, Union
 
 logger = logging.getLogger(__name__)
 
@@ -21,9 +22,9 @@ class OrderBook:
                 self.asks[str(i[0])] = str(abs(i[2]))
 
     def get_book(self) -> dict:
-        bids = list(map(list, self.bids.items()))
+        bids = [list(item) for item in self.bids.items()]
         bids.sort(key=lambda x: float(x[0]), reverse=True)
-        asks = list(map(list, self.asks.items()))
+        asks = [list(item) for item in self.asks.items()]
         asks.sort(key=lambda x: float(x[0]), reverse=False)
         return {
             'stream': f"{self.symbol}@depth5",
@@ -270,15 +271,32 @@ def orders(res: list, response_type=None, cancelled=False) -> list:
     return binance_orders
 
 
-def order_book(res: list) -> dict:
-    binance_order_book = {"lastUpdateId": int(time.time() * 1000)}
-    bids = []
-    asks = []
+def order_book(res: List[List[float]]) -> Dict[str, Union[int, List[List[str]]]]:
+    """
+    Processes a list of raw order book entries into a structured dictionary.
+
+    Args:
+        res: A list of order entries, where each entry is a list like
+             [price (float), quantity (float), side_indicator (float)].
+             side_indicator > 0 for bids, < 0 for asks.
+
+    Returns:
+        A dictionary representing the order book with 'lastUpdateId', 'bids', and 'asks'.
+    """
+    binance_order_book: Dict[str, Union[int, List[List[str]]]] = {
+        "lastUpdateId": int(time.time() * 1000)
+    }
+
+    bids: List[List[str]] = []
+    asks: List[List[str]] = []
+
     for i in res:
-        if i[2] > 0:
-            bids.append([str(i[0]), str(i[2])])
-        else:
-            asks.append([str(i[0]), str(abs(i[2]))])
+        # Assuming i[2] determines bid/ask side and its absolute value is the quantity
+        if i[2] > 0: # This means it's a bid (positive quantity indicator)
+            bids.append([str(i[0]), str(i[2])]) # price, quantity
+        else: # This means it's an ask (negative quantity indicator or zero)
+            asks.append([str(i[0]), str(abs(i[2]))]) # price, absolute quantity
+
     binance_order_book['bids'] = bids
     binance_order_book['asks'] = asks
     return binance_order_book
@@ -435,7 +453,7 @@ def ticker(res: list, symbol: str = None) -> dict:
 
 
 def on_funds_update(res: list) -> dict:
-    binance_funds = {
+    binance_funds: Dict[str, Union[str, int, List]] = {
         'e': 'outboundAccountPosition',
         'E': int(time.time() * 1000),
         'u': int(time.time() * 1000),

{exchanges_wrapper-2.1.40 → exchanges_wrapper-2.1.42}/exchanges_wrapper/parsers/bybit.py

@@ -23,8 +23,8 @@ class OrderBook:
             'stream': f"{self.symbol}@depth5",
             'data': {
                 'lastUpdateId': self.last_update_id,
-                'bids': list(map(list, self.bids.items()))[:5],
-                'asks': list(map(list, self.asks.items()))[:5],
+                'bids': [list(item) for item in self.bids.items()][:5],
+                'asks': [list(item) for item in self.asks.items()][:5],
             },
         }
 

{exchanges_wrapper-2.1.40 → exchanges_wrapper-2.1.42}/exchanges_wrapper/parsers/okx.py

@@ -3,6 +3,7 @@ Parser for convert OKX REST API/WSS V5 response to Binance like result
 """
 import time
 from decimal import Decimal
+from typing import Dict, List, Union
 import logging
 
 logger = logging.getLogger(__name__)
@@ -14,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:
@@ -97,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
@@ -185,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"]),
@@ -214,10 +215,14 @@ def account_balances(res: list) -> dict:
     return {"balances": balances}
 
 
-def order_book(res: dict) -> dict:
-    asks = []
-    bids = []
-    binance_order_book = {"lastUpdateId": int(res.get('ts'))}
+def order_book(res: dict) -> Dict[str, Union[int, List[List[str]]]]:
+    binance_order_book: Dict[str, Union[int, List[List[str]]]] = {
+        "lastUpdateId": int(time.time() * 1000)
+    }
+
+    bids: List[List[str]] = []
+    asks: List[List[str]] = []
+
     [asks.append(ask[:2]) for ask in res.get('asks')]
     binance_order_book['asks'] = asks
     [bids.append(bid[:2]) for bid in res.get('bids')]
@@ -225,7 +230,7 @@ def order_book(res: dict) -> dict:
     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')))
@@ -258,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",
@@ -339,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_', '')
@@ -373,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",
@@ -381,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 = []
@@ -403,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')
@@ -459,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.40 → exchanges_wrapper-2.1.42}/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} 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:
@@ -246,21 +263,23 @@ class EventsDataStream:
             try:
                 await self.websocket.send(json.dumps({"req_id": req_id, "op": "ping"}))
             except (ConnectionClosed, asyncio.exceptions.TimeoutError):
-                pass  # handled elsewhere
+                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")
+        self.logger.warning("From HTX server PING timeout exceeded")
         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 +290,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 +349,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 +409,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 +444,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 +467,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 +527,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 +585,7 @@ class OkxPrivateEventsDataStream(EventsDataStream):
 
 
 class BBTPrivateEventsDataStream(EventsDataStream):
+    __slots__ = ()
 
     async def start_wss(self):
         ts = int((time.time() + 1) * 1000)
@@ -591,7 +616,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 +628,7 @@ class BBTPrivateEventsDataStream(EventsDataStream):
 
 
 class UserEventsDataStream(EventsDataStream):
+    __slots__ = ()
 
     async def start_wss(self):
         await self.websocket.send(
@@ -620,5 +646,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.40 → exchanges_wrapper-2.1.42}/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.0.20",
+    "crypto-ws-api==2.1.3",
     "pyotp==2.9.0",
-    "simplejson==3.20.1",
-    "aiohttp~=3.12.13",
+    "simplejson==3.20.2",
+    "aiohttp~=3.13.0",
     "expiringdict~=1.2.2",
     "betterproto==2.0.0b7",
     "grpclib~=0.4.8"