crypto-ws-api 2.1.2__tar.gz → 2.1.4__tar.gz

{crypto_ws_api-2.1.2 → crypto_ws_api-2.1.4}/CHANGELOG.md

@@ -1,3 +1,16 @@
+## 2.1.4 - 2025-12-02
+- Add optional root logger configuration to set_logger()
+- Introduce malloc_trim() wrapper for C library memory management
+- Invoke malloc_trim() in WSSession cleanup for memory optimization  
+- Update __init__.py and CHANGELOG.md for version 2.1.4
+
+## 2.1.3 - 2025-10-16
+✨ feat(ws_session.py): Add `tasks_cancel()` for structured task cancellation with logging  
+♻️ refactor(ws_session.py): Refactor task cancellation and stop logic to use `tasks_cancel()`  
+🔧 fix(ws_session.py): Update logger references for consistent logging throughout the module  
+🔧 chore(requirements.txt): Upgrade `platformdirs` to 4.5.0, `ujson` to 5.11.0, and `cryptography` to 46.0.3
+🔧 fix(ws_session.py): _improve memory usage_
+
 ## 2.1.2 - 2025-08-10
 ♻️ refactor(demo/demo_loop): Store demo_loop coroutines in variables for reference
 

{crypto_ws_api-2.1.2 → crypto_ws_api-2.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: crypto-ws-api
-Version: 2.1.2
+Version: 2.1.4
 Summary: Crypto WS API connector for ASYNC requests
 Author-email: Jerry Fedorenko <jerry.fedorenko@yahoo.com>
 Requires-Python: >=3.10
@@ -11,13 +11,12 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: Unix
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: MacOS
-License-File: LICENSE.md
 Requires-Dist: shortuuid~=1.0.13
-Requires-Dist: platformdirs==4.3.8
+Requires-Dist: platformdirs==4.5.0
 Requires-Dist: toml~=0.10.2
 Requires-Dist: websockets==15.0.1
-Requires-Dist: ujson~=5.10.0
-Requires-Dist: cryptography~=45.0.6
+Requires-Dist: ujson~=5.11.0
+Requires-Dist: cryptography~=46.0.3
 Project-URL: Source, https://github.com/DogsTailFarmer/crypto-ws-api
 
 <h1 align="center"><img align="center" src="https://user-images.githubusercontent.com/77513676/250364389-cbedc171-a930-4467-a0cd-21627a6a41ed.svg" width="75">Crypto WS API connector for ASYNC requests</h1>

{crypto_ws_api-2.1.2 → crypto_ws_api-2.1.4}/crypto_ws_api/__init__.py

@@ -13,7 +13,7 @@ __maintainer__ = "Jerry Fedorenko"
 __contact__ = "https://github.com/DogsTailFarmer"
 __email__ = "jerry.fedorenko@yahoo.com"
 __credits__ = ["https://github.com/DanyaSWorlD"]
-__version__ = "2.1.2"
+__version__ = "2.1.4"
 
 from pathlib import Path
 import shutil
@@ -22,7 +22,7 @@ from platformdirs import user_config_path
 VERSION = __version__
 TIMEOUT = 5  # sec timeout for WSS initialization and get response
 DELAY = 0.1  # sec delay in keepalive loop
-DEBUG_LOG = 'debug'  # The name of the exchange for which log files, separated by trade_id with DEBUG level, will be generated
+DEBUG_LOG = 'debug'  # The exchange for which log files, separated by trade_id with DEBUG level, will be generated
 # Maximum str size for unique query ID
 ID_LEN_LIMIT = {
     "binance": 36,

{crypto_ws_api-2.1.2 → crypto_ws_api-2.1.4}/crypto_ws_api/ws_session.py

@@ -17,6 +17,7 @@ from datetime import datetime, timezone
 from urllib.parse import urlencode, urlparse
 from cryptography.hazmat.primitives.serialization import load_pem_private_key
 import inspect
+import ctypes, ctypes.util
 
 from websockets.asyncio.client import connect
 from websockets import ConnectionClosed
@@ -31,7 +32,7 @@ sys.tracebacklimit = 0
 ALPHABET = string.ascii_letters + string.digits
 CONST_WS_START = "userDataStream.start"
 
-def set_logger(name, log_file, file_level=logging.INFO, propagate=False):
+def set_logger(name, log_file, file_level=logging.INFO, propagate=False, set_root_logger=False):
     formatter = logging.Formatter(fmt="[%(asctime)s: %(levelname)s] %(message)s")
     #
     fh = logging.handlers.RotatingFileHandler(log_file, maxBytes=1000000, backupCount=10)
@@ -47,10 +48,18 @@ def set_logger(name, log_file, file_level=logging.INFO, propagate=False):
     _logger.addHandler(sh)
     _logger.propagate = propagate
 
+    if set_root_logger:
+        root_logger = logging.getLogger()
+        root_logger.setLevel(min([fh.level, sh.level]))
+        root_logger.addHandler(fh)
+        root_logger.addHandler(sh)
+
     return _logger
 
 logger = set_logger(__name__, Path(LOG_PATH, 'ws_session.log'))
 
+def malloc_trim(trim_type: int = 0):
+    ctypes.CDLL(ctypes.util.find_library('c')).malloc_trim(trim_type)
 
 def generate_signature(exchange: str, secret: str, data: str) -> str:
     encoding = "utf-8"
@@ -75,7 +84,7 @@ def generate_signature(exchange: str, secret: str, data: str) -> str:
         return signature.hexdigest()
 
 def compose_binance_ws_auth(_id: str, api_key: str, api_secret: str) -> dict:
-    req = {"id": _id, "method": "session.logon"}
+    req: dict[str, str | dict[str, str | int]] = {"id": _id, "method": "session.logon"}
     params = {
         "apiKey": api_key,
         "timestamp": int(time.time() * 1000)
@@ -109,6 +118,18 @@ def tasks_manage(tasks_set: set, coro, name=None, add_done_callback=True):
     if add_done_callback:
         _t.add_done_callback(tasks_set.discard)
 
+async def tasks_cancel(tasks_set: set, _logger=logger):
+    tasks = tasks_set.copy()
+    for task in tasks:
+        task.cancel()
+        flag = None
+        try:
+            await task
+        except asyncio.CancelledError:  # NOSONAR
+            flag = True
+        finally:
+            _logger.info(f"The task {task.get_name()} was cancelled {'by force' if flag else ''}")
+    tasks_set.clear()
 
 # https://binance-docs.github.io/apidocs/websocket_api/en/#rate-limits
 class RateLimitInterval(Enum):
@@ -136,7 +157,8 @@ class UserWSS:
         "_response_pool",
         "tasks",
         "ping",
-        "logger"
+        "logger",
+        "stopped"
     )
 
     def __init__(self, ws_id, exchange, endpoint, api_key, api_secret, passphrase=None, trade_id=None):
@@ -157,28 +179,27 @@ class UserWSS:
         self.in_event = asyncio.Event()
         self.tasks = set()
         self.ping = 0
+        self.stopped = False
 
         if self.exchange == DEBUG_LOG:
-            if trade_id in logging.root.manager.loggerDict:
-                logger.info(f"Logger {trade_id} already exists")
-                self.logger = logging.root.manager.loggerDict[trade_id]
+            log_key = f"ws_{trade_id}"
+            if log_key in logging.root.manager.loggerDict:
+                self.logger = logging.root.manager.loggerDict[log_key]
             else:
-                self.logger = set_logger(trade_id, Path(LOG_PATH, f"ws_{trade_id}.log"), logging.DEBUG)
+                self.logger = set_logger(log_key, Path(LOG_PATH, f"{log_key}.log"), logging.DEBUG)
         else:
             self.logger = logger
 
-    async def _ws_listener(self):  #NOSONAR
+    async def _ws_listener(self):  # NOSONAR(S3776)
         tasks_manage(self.tasks, self.ws_login(), f"ws_login-{self.ws_id}")
         async for msg in self._ws:
-            # logger.info(f"_ws_listener: ws_id: {self.ws_id} msg: {msg}")
             if isinstance(msg, str):
                 try:
                     _msg = json.loads(msg)
                 except JSONDecodeError:
-                    logger.warning(f"UserWSS: {self.ws_id}: {msg}")
+                    self.logger.warning(f"UserWSS JSONDecodeError: {self.ws_id}: {msg}")
                 else:
                     res = await self._handle_msg(_msg)
-                    # logger.info(f"_ws_listener: res: {self.ws_id}: {res}")
                     if res != 'pass':
                         if res is None:
                             self._response_pool[f"NoneResponse{self.ws_id}"] = None
@@ -189,50 +210,71 @@ class UserWSS:
                         elif self.exchange == 'huobi':
                             self._response_pool[res.get('cid') or self.ws_id] = res.get('data')
                         self.in_event.set()
-                        # logger.info(f"_ws_listener: _response_pool: {self._response_pool}")
                     await asyncio.sleep(0)
             else:
-                logger.warning(f"UserWSS: {self.ws_id}: {msg}")
-                await self.stop()
+                self.logger.warning(f"UserWSS: {self.ws_id}: {msg}")
+                break
+        self.logger.info(f"UserWSS listener loop for {self.ws_id} stopped")
+
+    async def stop(self):
+        """
+        Stop data stream
+        """
+        if not self.stopped:
+            self.stopped = True
+            self.operational_status = None  # Not restart and break all loops
+            self.order_handling = False
+            if self._ws:
+                await self._ws.close(code=4000)
+                self._ws = None
+            await self.cycle_init()
+            self.logger.info(f"User WSS for {self.ws_id} stopped")
+
+    async def cycle_init(self):
+        await tasks_cancel(self.tasks, _logger=self.logger)
+        self._response_pool.clear()
+        gc.collect()
+        malloc_trim()
 
     async def start_wss(self):
-        try:
-            async for self._ws in connect(
-                    self.endpoint,
-                    logger=self.logger,
-                    ping_interval=None if self.exchange in ('binance', 'huobi') else 20
-            ):
-                try:
-                    await self._ws_listener()
-                except ConnectionClosed as ex:
-                    if ex.rcvd and ex.rcvd.code == 4000:
-                        logger.info(f"WSS closed for {self.ws_id}")
-                        break
-                    else:
-                        self.operational_status = False
-                        [task.cancel() for task in self.tasks if not task.done()]
-                        self.tasks.clear()
-                        logger.warning(f"Restart UserWSS for {self.ws_id}")
-                        continue
-                except Exception as ex:
-                    logger.error(f"UserWSS start other exception: {ex}")
-        except asyncio.CancelledError:
-            await self.stop()
-            raise
+        async for self._ws in connect(
+                self.endpoint,
+                logger=self.logger,
+                ping_interval=None if self.exchange in ('binance', 'huobi') else 20
+        ):
+            try:
+                await self._ws_listener()
+            except ConnectionClosed as ex:
+                self._ws = None
+                if ex.rcvd and ex.rcvd.code == 4000:
+                    self.logger.info(f"WSS closed for {self.ws_id}")
+                    break
+                else:
+                    self.operational_status = False
+                    await self.cycle_init()
+                    self.logger.warning(f"Restart UserWSS for {self.ws_id}")
+                    continue
+            except Exception as ex:
+                self.logger.error(f"UserWSS start other exception: {ex}")
+                break
+            break
+        self.logger.info(f"UserWSS start loop for {self.ws_id} stopped")
+        await self.stop()
 
     async def ws_login(self):
         res = await self.request(CONST_WS_START)
         if res is None:
-            logger.warning(f"UserWSS: Not 'logged in' for {self.ws_id}")
+            self.logger.warning(f"UserWSS: Not 'logged in' for {self.ws_id}")
             await self.stop()
         else:
+            self.operational_status = True
+            self.order_handling = True
+
             if self.exchange == 'huobi':
                 tasks_manage(self.tasks, self.htx_keepalive(), f"htx_keepalive-{self.ws_id}")
 
-            self.operational_status = True
-            self.order_handling = True
             tasks_manage(self.tasks, self._keepalive(), f"keepalive-{self.ws_id}")
-            logger.info(f"UserWSS: 'logged in' for {self.ws_id}")
+            self.logger.info(f"UserWSS: 'logged in' for {self.ws_id}")
 
     async def request(self, method, _params=None, _signed=False):
         """
@@ -241,13 +283,13 @@ class UserWSS:
         :return: result: {} or None if temporary Out-of-Service state
         """
         if self.request_limit_reached:
-            logger.warning(f"UserWSS {self.ws_id}: request limit reached, try later")
+            self.logger.warning(f"UserWSS {self.ws_id}: request limit reached, try later")
             return None
         if method != CONST_WS_START and not self.operational_status:
-            logger.warning("UserWSS temporary in Out-of-Service state")
+            self.logger.warning("UserWSS temporary in Out-of-Service state")
             return None
         if method in ('order.place', 'order.cancelReplace', 'order', 'create-order') and not self.order_handling:
-            logger.warning("UserWSS: exceeded order placement limit, try later")
+            self.logger.warning("UserWSS: exceeded order placement limit, try later")
             return None
         params = _params.copy() if _params else None
         r_id = f"{self.exchange}{method}{''.join(random.choices(ALPHABET, k=8))}"  #NOSONAR
@@ -262,7 +304,7 @@ class UserWSS:
         try:
             res = await asyncio.wait_for(self._response_distributor(_id), timeout=TIMEOUT)
         except asyncio.exceptions.TimeoutError:
-            logger.warning(f"UserWSS: get response timeout error: {self.ws_id}")
+            self.logger.warning(f"UserWSS: get response timeout error: {self.ws_id}")
             await self.stop()
             return None
         else:
@@ -343,37 +385,24 @@ class UserWSS:
         while self.operational_status is not None:
             if self.request_limit_reached and (int(time.time() * 1000) - self._retry_after >= 0):
                 self.request_limit_reached = False
-                logger.info(f"UserWSS: request limit reached restored for {self.ws_id}")
+                self.logger.info(f"UserWSS: request limit reached restored for {self.ws_id}")
             if not self.order_handling and (int(time.time() * 1000) - self._retry_after >= 0):
                 self.order_handling = True
-                logger.info(f"UserWSS order handling status restored for {self.ws_id}")
+                self.logger.info(f"UserWSS order handling status restored for {self.ws_id}")
             await asyncio.sleep(interval)
 
     async def htx_keepalive(self, interval=60):
         await asyncio.sleep(interval * 10)
-        while True:
+        while self.operational_status is not None:
             await asyncio.sleep(interval)
             if self.ping:
+                self.logger.warning("From HTX server PING timeout exceeded")
                 break
             else:
                 self.ping = 1
-        logger.warning("From HTX server PING timeout exceeded")
+        self.logger.info(f"UserWSS htx_keepalive loop for {self.ws_id} stopped")
         await self.stop()
 
-    async def stop(self):
-        """
-        Stop data stream
-        """
-        self.operational_status = None  # Not restart and break all loops
-        self.order_handling = False
-        self.init = True
-        [task.cancel() for task in self.tasks if not task.done()]
-        self.tasks.clear()
-        if self._ws:
-            await self._ws.close(code=4000)
-        gc.collect()
-        logger.info(f"User WSS for {self.ws_id} stopped")
-
     async def _handle_msg(self, msg):
         if self.exchange == 'binance':
             self._handle_rate_limits(msg.pop('rateLimits', []))
@@ -408,13 +437,13 @@ class UserWSS:
 
     def htx_error_handle(self, msg):
         if msg.get('code') == 500:
-            logger.warning(f"An issue occurred on exchange's side: {msg}")
+            self.logger.warning(f"An issue occurred on exchange's side: {msg}")
         elif msg.get('code') in {429, 4000}:
             self._retry_after = int((time.time() + TIMEOUT) * 1000)
             self.request_limit_reached = True
-            logger.warning(f"HTX WSS exceed limit: {msg}")
+            self.logger.warning(f"HTX WSS exceed limit: {msg}")
         else:
-            logger.warning(f"Malformed request: status: {msg}")
+            self.logger.warning(f"Malformed request: status: {msg}")
 
     # region BitfinexErrorHandle
     async def bitfinex_error_handle(self, msg):
@@ -437,20 +466,20 @@ class UserWSS:
 
     async def _handle_info_event(self, msg):
         if not msg.get('platform', {}).get('status'):
-            logger.warning(f"UserWSS Bitfinex platform in maintenance mode: {msg}")
+            self.logger.warning(f"UserWSS Bitfinex platform in maintenance mode: {msg}")
             await self.stop()
         elif msg.get('version') != 2:
-            logger.critical('Bitfinex WSS platform: version change detected')
+            self.logger.critical('Bitfinex WSS platform: version change detected')
         return 'pass'
 
     def _handle_error_code(self, msg):
         code = msg.get('code')
         if code == 10305:
-            logger.warning('UserWSS Bitfinex: Reached limit of open channels')
+            self.logger.warning('UserWSS Bitfinex: Reached limit of open channels')
             self._retry_after = int((time.time() + TIMEOUT) * 1000)
             self.request_limit_reached = True
         else:
-            logger.warning(f"Malformed request for {self.ws_id}: {msg}")
+            self.logger.warning(f"Malformed request for {self.ws_id}: {msg}")
 
     @staticmethod
     def _transform_list_message(msg):
@@ -471,18 +500,18 @@ class UserWSS:
 
     def okx_error_handle(self, msg):
         if msg.get('code') == '1':
-            logger.warning(f"OKX User WSS operation failed: {msg}")
+            self.logger.warning(f"OKX User WSS operation failed: {msg}")
         elif msg.get('code') == '63999':
-            logger.warning(f"An issue occurred on exchange's side: {msg}")
+            self.logger.warning(f"An issue occurred on exchange's side: {msg}")
         elif msg.get('code') == '60014':
             self._retry_after = int((time.time() + TIMEOUT) * 1000)
             self.request_limit_reached = True
         else:
-            logger.warning(f"Malformed request: status: {msg}")
+            self.logger.warning(f"Malformed request: status: {msg}")
 
     async def binance_error_handle(self, msg):
         error_msg = msg.get('error')
-        logger.error(f"Malformed request: status: {error_msg}")
+        self.logger.error(f"Malformed request: status: {error_msg}")
         if msg.get('status') in (401, 403):
             await self.stop()
         if msg.get('status') in (418, 429):
@@ -511,6 +540,7 @@ class UserWSSession:
         "_passphrase",
         "user_wss",
         "tasks_wss",
+        "logger",
     )
 
     def __init__(self, exchange, endpoint, api_key, api_secret, passphrase=None):
@@ -524,8 +554,9 @@ class UserWSSession:
         self._passphrase = passphrase
         self.user_wss = {}
         self.tasks_wss = set()
+        self.logger = logger
 
-    async def handle_request(
+    async def handle_request(  # NOSONAR(S3776)
         self,
         trade_id: str,
         method: str,
@@ -533,15 +564,29 @@ class UserWSSession:
         _signed=False,
     ):
 
+        if self.exchange == DEBUG_LOG:
+            log_key = f"ws_{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)
+
         ws_id = f"{self.exchange}-{trade_id}"
         if self.exchange in ('binance', 'vertex'):
             ws_id = f"{ws_id}{'_ST' if _signed else '_SF'}"
         else:
             ws_id = f"{ws_id}-{method}"
 
+
+        init_session = True
         if ws_id in self.user_wss:
             user_wss = self.user_wss[ws_id]
-        else:
+            if user_wss.stopped:
+                await self.stop(ws_id)
+            else:
+                init_session = False
+
+        if init_session:
             user_wss = UserWSS(
                     ws_id,
                     self.exchange,
@@ -553,6 +598,7 @@ class UserWSSession:
                 )
             self.user_wss[ws_id] = user_wss
 
+        # noinspection PyUnboundLocalVariable
         if user_wss.init:
             user_wss.init = False
             user_wss.operational_status = False
@@ -562,7 +608,7 @@ class UserWSSession:
         while not (user_wss.operational_status and user_wss.order_handling):
             await asyncio.sleep(DELAY)
             if duration > TIMEOUT:
-                logger.warning(f"{trade_id}: Register timeout for method '{method}'")
+                self.logger.warning(f"{trade_id}: Register timeout for method '{method}'")
                 return None
             duration += DELAY
 
@@ -571,14 +617,24 @@ class UserWSSession:
         except KeyboardInterrupt:
             pass  # Task cancellation should not be logged as an error
         except Exception as ex:
-            logger.error(f"crypto_ws_api.ws_session.handle_request(): {ex}")
-        logger.warning(f"{trade_id}: {method}: None response")
+            self.logger.error(f"crypto_ws_api.ws_session.handle_request(): {ex}")
+        self.logger.warning(f"{trade_id}: {method}: None response")
         return None
 
-    async def stop(self):
-        user_wss_copy = dict(self.user_wss)
-        for ws in user_wss_copy.values():
-            await ws.stop()
-        self.user_wss.clear()
-        [task.cancel() for task in self.tasks_wss if not task.done()]
-        self.tasks_wss.clear()
+    async def stop(self, _trade_id):
+        user_wss_to_stop = []
+        for key in list(self.user_wss.keys()):  # NOSONAR
+            if _trade_id in key:
+                user_wss_to_stop.append((key, self.user_wss.pop(key)))
+
+        # Stop each UserWSS instance and clean up
+        await asyncio.gather(*[ws.stop() for _, ws in user_wss_to_stop])
+
+        # Remove related tasks
+        to_cancel = set()
+        for task in self.tasks_wss:
+            if _trade_id in task.get_name():
+                to_cancel.add(task)
+
+        self.tasks_wss.difference_update(to_cancel)
+        await tasks_cancel(to_cancel, _logger=self.logger)

{crypto_ws_api-2.1.2 → crypto_ws_api-2.1.4}/pyproject.toml

@@ -18,11 +18,11 @@ requires-python = ">=3.10"
 
 dependencies = [
     "shortuuid~=1.0.13",
-    "platformdirs==4.3.8",
+    "platformdirs==4.5.0",
     "toml~=0.10.2",
     "websockets==15.0.1",
-    "ujson~=5.10.0",
-    "cryptography~=45.0.6"
+    "ujson~=5.11.0",
+    "cryptography~=46.0.3"
 ]
 
 [tool.flit.module]

crypto_ws_api-2.1.4/requirements.txt

@@ -0,0 +1,6 @@
+shortuuid~=1.0.13
+platformdirs==4.5.0
+toml~=0.10.2
+websockets==15.0.1
+ujson~=5.11.0
+cryptography~=46.0.3

crypto_ws_api-2.1.2/requirements.txt

@@ -1,6 +0,0 @@
-shortuuid~=1.0.13
-platformdirs==4.3.8
-toml~=0.10.2
-websockets==15.0.1
-ujson~=5.10.0
-cryptography~=45.0.6