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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: exchanges-wrapper
-Version: 2.1.42
+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.3
+Requires-Dist: crypto-ws-api==2.1.4
 Requires-Dist: pyotp==2.9.0
 Requires-Dist: simplejson==3.20.2
-Requires-Dist: aiohttp~=3.13.0
+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.42 → 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.42"
+__version__ = "2.1.43"
 
 from pathlib import Path
 import shutil

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

@@ -51,7 +51,7 @@ class Client:
         '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',
+        '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',
@@ -98,7 +98,6 @@ class Client:
         else:
             self.user_session = None
         #
-        self.loaded = False
         self.symbols = {}
         self.highest_precision = None
         self.rate_limits = None
@@ -150,7 +149,6 @@ 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):
@@ -229,7 +227,7 @@ class Client:
             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:
@@ -279,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):

{exchanges_wrapper-2.1.42 → 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
@@ -41,24 +44,12 @@ 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:
@@ -94,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):
@@ -144,7 +135,7 @@ class Martin(mr.MartinBase):
             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.close_session()
-            OpenClient.remove_client(request.account_name)
+            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}")
@@ -258,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,
@@ -269,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,
@@ -284,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 |= {
@@ -529,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:
@@ -774,19 +766,23 @@ class Martin(mr.MartinBase):
         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:
-            await session.close_session()
-        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)
 
 
@@ -797,7 +793,9 @@ async def stop_stream_ex(client, 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):
@@ -841,5 +839,6 @@ def main():
         print(f"Exception: {expt}")
         print(traceback.format_exc())
 
+
 if __name__ == '__main__':
     main()

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

@@ -84,7 +84,7 @@ class EventsDataStream:
             except ConnectionClosed as ex:
                 self.websocket = None
                 ct = str(datetime.now(timezone.utc).replace(tzinfo=None) - start_time).rsplit('.')[0]
-                self.logger.info(f"WSS life time for {self.exchange} is {ct}")
+                self.logger.info(f"WSS life time for {self.exchange}:{self.trade_id} is {ct}")
                 if ex.rcvd and ex.rcvd.code == 4000:
                     self.logger.info(f"WSS closed for {self.exchange}:{self.trade_id}")
                     break
@@ -262,7 +262,7 @@ class EventsDataStream:
             await asyncio.sleep(interval)
             try:
                 await self.websocket.send(json.dumps({"req_id": req_id, "op": "ping"}))
-            except (ConnectionClosed, asyncio.exceptions.TimeoutError):
+            except (ConnectionClosed, asyncio.exceptions.TimeoutError, AttributeError):
                 break
 
     async def htx_keepalive(self, interval=60):
@@ -274,7 +274,8 @@ class EventsDataStream:
             else:
                 self.ping = 1
         self.logger.warning("From HTX server PING timeout exceeded")
-        await self.websocket.close()
+        if self.websocket:
+            await self.websocket.close()
 
 
 class MarketEventsDataStream(EventsDataStream):

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

@@ -20,10 +20,10 @@ dynamic = ["version", "description"]
 requires-python = ">=3.10"
 
 dependencies = [
-    "crypto-ws-api==2.1.3",
+    "crypto-ws-api==2.1.4",
     "pyotp==2.9.0",
     "simplejson==3.20.2",
-    "aiohttp~=3.13.0",
+    "aiohttp~=3.13.2",
     "expiringdict~=1.2.2",
     "betterproto==2.0.0b7",
     "grpclib~=0.4.8"