crypto-ws-api 2.1.0__tar.gz → 2.1.3__tar.gz

{crypto_ws_api-2.1.0 → crypto_ws_api-2.1.3}/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 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
+
+## 2.1.1 - 2025-08-10
+♻️ refactor(ws_session): introduce `tasks_manage` for centralized task handling  
+♻️ chore(deps): update platformdirs and cryptography to latest versions
+
 ## 2.1.0 - 2025-06-22
 ✨ refactor(ws_session.py): simplify `ws_login` and `request` methods by removing redundant `send_api_key` parameter.
 

{crypto_ws_api-2.1.0 → crypto_ws_api-2.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: crypto-ws-api
-Version: 2.1.0
+Version: 2.1.3
 Summary: Crypto WS API connector for ASYNC requests
 Author-email: Jerry Fedorenko <jerry.fedorenko@yahoo.com>
 Requires-Python: >=3.10
@@ -12,11 +12,11 @@ Classifier: Operating System :: Unix
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: MacOS
 Requires-Dist: shortuuid~=1.0.13
-Requires-Dist: platformdirs==4.3.6
+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~=44.0.2
+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.0 → crypto_ws_api-2.1.3}/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.0"
+__version__ = "2.1.3"
 
 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.0 → crypto_ws_api-2.1.3}/crypto_ws_api/demo.py

@@ -43,8 +43,8 @@ async def main(account_name):
 
     # Demo method's calling
     await account_information(user_session, trade_id)
-    asyncio.ensure_future(demo_loop(user_session, get_time, trade_id, 2))
-    asyncio.ensure_future(demo_loop(user_session, current_average_price, trade_id, 3))
+    _t1 = asyncio.ensure_future(demo_loop(user_session, get_time, trade_id, 2))
+    _t2 = asyncio.ensure_future(demo_loop(user_session, current_average_price, trade_id, 3))
 
     await asyncio.sleep(20)
 

{crypto_ws_api-2.1.0 → crypto_ws_api-2.1.3}/crypto_ws_api/ws_session.py

@@ -16,6 +16,7 @@ import random
 from datetime import datetime, timezone
 from urllib.parse import urlencode, urlparse
 from cryptography.hazmat.primitives.serialization import load_pem_private_key
+import inspect
 
 from websockets.asyncio.client import connect
 from websockets import ConnectionClosed
@@ -74,7 +75,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)
@@ -102,6 +103,25 @@ def compose_htx_ws_auth(endpoint, exchange, api_key, api_secret):
         "params": _params
     }
 
+def tasks_manage(tasks_set: set, coro, name=None, add_done_callback=True):
+    _t = asyncio.create_task(coro, name=name or inspect.stack()[1][3])
+    tasks_set.add(_t)
+    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):
     SECOND = 1
@@ -128,7 +148,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):
@@ -149,33 +170,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
 
-    def tasks_manage(self, coro, name=None):
-        _t = asyncio.create_task(coro, name=name)
-        self.tasks.add(_t)
-        _t.add_done_callback(self.tasks.discard)
-
-    async def _ws_listener(self):
-        self.tasks_manage(self.ws_login())
+    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
@@ -186,50 +201,70 @@ 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()
 
     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:
-            if self.exchange == 'huobi':
-                self.tasks_manage(self.htx_keepalive(), f"htx_keepalive-{self.ws_id}")
-
             self.operational_status = True
             self.order_handling = True
-            self.tasks_manage(self._keepalive(), f"keepalive-{self.ws_id}")
-            logger.info(f"UserWSS: 'logged in' for {self.ws_id}")
+
+            if self.exchange == 'huobi':
+                tasks_manage(self.tasks, self.htx_keepalive(), f"htx_keepalive-{self.ws_id}")
+
+            tasks_manage(self.tasks, self._keepalive(), f"keepalive-{self.ws_id}")
+            self.logger.info(f"UserWSS: 'logged in' for {self.ws_id}")
 
     async def request(self, method, _params=None, _signed=False):
         """
@@ -238,16 +273,16 @@ 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))}"
+        r_id = f"{self.exchange}{method}{''.join(random.choices(ALPHABET, k=8))}"  #NOSONAR
         if self.exchange in ("okx", "bitfinex", "huobi") and method == CONST_WS_START:
             _id = self.ws_id
         else:
@@ -259,7 +294,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:
@@ -340,37 +375,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', []))
@@ -405,13 +427,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):
@@ -434,20 +456,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):
@@ -468,18 +490,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):
@@ -508,6 +530,7 @@ class UserWSSession:
         "_passphrase",
         "user_wss",
         "tasks_wss",
+        "logger",
     )
 
     def __init__(self, exchange, endpoint, api_key, api_secret, passphrase=None):
@@ -521,8 +544,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,
@@ -530,15 +554,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,
@@ -550,18 +588,17 @@ class UserWSSession:
                 )
             self.user_wss[ws_id] = user_wss
 
+        # noinspection PyUnboundLocalVariable
         if user_wss.init:
             user_wss.init = False
             user_wss.operational_status = False
-            _t = asyncio.create_task(user_wss.start_wss())
-            self.tasks_wss.add(_t)
-            _t.add_done_callback(self.tasks_wss.discard)
+            tasks_manage(self.tasks_wss, user_wss.start_wss(), f"start_wss-{ws_id}")
 
         duration = 0
         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
 
@@ -570,14 +607,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.0 → crypto_ws_api-2.1.3}/pyproject.toml

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

crypto_ws_api-2.1.3/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.0/requirements.txt

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