crypto-ws-api 2.0.13__tar.gz → 2.0.15__tar.gz

{crypto-ws-api-2.0.13 → crypto_ws_api-2.0.15}/CHANGELOG.md

@@ -1,3 +1,16 @@
+## 2.0.15 - 2024-12-16
+### Added for new features
+* `HTX` implemented
+
+### Update
+* reused WS connection grouped by private and public methods
+* `websockets`: bump to v14.1
+* some minor improvements
+
+## 2.0.14 - 2024-09-13
+### Update
+* `pyproject.toml`
+
 ## 2.0.13 - 2024-09-13
 ### Update
 * Dependencies

{crypto-ws-api-2.0.13 → crypto_ws_api-2.0.15}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: crypto-ws-api
-Version: 2.0.13
+Version: 2.0.15
 Summary: Crypto WS API connector for ASYNC requests
 Author-email: Jerry Fedorenko <jerry.fedorenko@yahoo.com>
 Requires-Python: >=3.8
@@ -11,10 +11,10 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: Unix
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: MacOS
-Requires-Dist: shortuuid~=1.0.11
-Requires-Dist: platformdirs~=3.10.0
+Requires-Dist: shortuuid~=1.0.13
+Requires-Dist: platformdirs==3.11.0
 Requires-Dist: toml~=0.10.2
-Requires-Dist: websockets~=12.0
+Requires-Dist: websockets==14.1
 Requires-Dist: ujson~=5.10.0
 Project-URL: Source, https://github.com/DogsTailFarmer/crypto-ws-api
 
@@ -32,7 +32,7 @@ Project-URL: Source, https://github.com/DogsTailFarmer/crypto-ws-api
 <a href="https://sonarcloud.io/summary/new_code?id=DogsTailFarmer_crypto-ws-api" target="_blank"><img alt="sonarcloud" title="sonarcloud" src="https://sonarcloud.io/api/project_badges/measure?project=DogsTailFarmer_crypto-ws-api&metric=alert_status"/></a>
 <a href="https://pepy.tech/project/crypto-ws-api" target="_blank"><img alt="Downloads" title="Downloads" src="https://static.pepy.tech/badge/crypto-ws-api"/></a>
 ***
-For :heavy_check_mark:Binance, :heavy_check_mark:OKX, :heavy_check_mark:Bitfinex
+For :heavy_check_mark:Binance, :heavy_check_mark:OKX, :heavy_check_mark:Bitfinex, :heavy_check_mark:HTX
 ***
 
 ## Features
@@ -40,6 +40,7 @@ Lightweight and efficient solution to utilize of all available methods** provide
 * [Binance Websocket API v3](https://binance-docs.github.io/apidocs/websocket_api/en)
 * [OKX Websocket API v5](https://www.okx.com/docs-v5/en/#overview-websocket)
 * [Bitfinex Websocket Inputs](https://docs.bitfinex.com/reference/ws-auth-input)
+* [HTX WS Trade](https://www.htx.com/en-us/opend/newApiPages/?id=8cb89359-77b5-11ed-9966-1928f079ab6)
 
 ** Not for channel by one-way subscription, for **_request <-> response_** mode only
 

{crypto-ws-api-2.0.13 → crypto_ws_api-2.0.15}/README.md

@@ -12,7 +12,7 @@
 <a href="https://sonarcloud.io/summary/new_code?id=DogsTailFarmer_crypto-ws-api" target="_blank"><img alt="sonarcloud" title="sonarcloud" src="https://sonarcloud.io/api/project_badges/measure?project=DogsTailFarmer_crypto-ws-api&metric=alert_status"/></a>
 <a href="https://pepy.tech/project/crypto-ws-api" target="_blank"><img alt="Downloads" title="Downloads" src="https://static.pepy.tech/badge/crypto-ws-api"/></a>
 ***
-For :heavy_check_mark:Binance, :heavy_check_mark:OKX, :heavy_check_mark:Bitfinex
+For :heavy_check_mark:Binance, :heavy_check_mark:OKX, :heavy_check_mark:Bitfinex, :heavy_check_mark:HTX
 ***
 
 ## Features
@@ -20,6 +20,7 @@ Lightweight and efficient solution to utilize of all available methods** provide
 * [Binance Websocket API v3](https://binance-docs.github.io/apidocs/websocket_api/en)
 * [OKX Websocket API v5](https://www.okx.com/docs-v5/en/#overview-websocket)
 * [Bitfinex Websocket Inputs](https://docs.bitfinex.com/reference/ws-auth-input)
+* [HTX WS Trade](https://www.htx.com/en-us/opend/newApiPages/?id=8cb89359-77b5-11ed-9966-1928f079ab6)
 
 ** Not for channel by one-way subscription, for **_request <-> response_** mode only
 

{crypto-ws-api-2.0.13 → crypto_ws_api-2.0.15}/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.0.13"
+__version__ = "2.0.15"
 
 from pathlib import Path
 import shutil

{crypto-ws-api-2.0.13 → crypto_ws_api-2.0.15}/crypto_ws_api/demo.py

@@ -101,7 +101,7 @@ async def account_information(user_session: UserWSSession, _trade_id):
         res = await user_session.handle_request(
             _trade_id,
             "account.status",
-            _api_key=True,
+            send_api_key=True,
             _signed=True
         )
         if res is None:

{crypto-ws-api-2.0.13 → crypto_ws_api-2.0.15}/crypto_ws_api/ws_session.py

@@ -6,39 +6,59 @@ import sys
 import time
 import logging
 import ujson as json
+from ujson import JSONDecodeError
 import hmac
 import hashlib
 import base64
 import string
 import random
-import websockets.client
+from datetime import datetime, timezone
+from urllib.parse import urlencode, urlparse
 
+from websockets.asyncio.client import connect
 from websockets import ConnectionClosed
 
 from enum import Enum
 from crypto_ws_api import TIMEOUT, ID_LEN_LIMIT, DELAY
 
-logger_ws = logger = logging.getLogger(__name__)
-logger_ws.level = logging.INFO
+logger = logging.getLogger(__name__)
+logger.level = logging.INFO
 sys.tracebacklimit = 0
 ALPHABET = string.ascii_letters + string.digits
-CONST_3 = "userDataStream.start"
-
-
-def generate_signature(exchange, api_secret, data):
-    if exchange == 'bitfinex':
-        sig = hmac.new(api_secret.encode("utf-8"), data.encode("utf-8"), hashlib.sha384).hexdigest()
-    elif exchange in ('huobi', 'okx'):
-        sig = hmac.new(api_secret.encode("utf-8"), data.encode("utf-8"), hashlib.sha256).digest()
-        sig = base64.b64encode(sig).decode()
-    elif exchange == 'binance_ws':
-        sig = hmac.new(api_secret.encode("ascii"), data.encode("ascii"), hashlib.sha256).hexdigest()
-    elif exchange == 'bybit':
-        sig = hmac.new(bytes(api_secret.encode("utf-8")), data.encode("utf-8"), hashlib.sha256).hexdigest()
-    else:
-        sig = hmac.new(api_secret.encode("utf-8"), data.encode("utf-8"), hashlib.sha256).hexdigest()
-    return sig
+CONST_WS_START = "userDataStream.start"
+
 
+def generate_signature(exchange: str, secret: str, data: str) -> str:
+    digest_func = hashlib.sha384 if exchange == 'bitfinex' else hashlib.sha256
+    encoding = "ascii" if exchange == 'binance_ws' else "utf-8"
+    key = secret.encode(encoding=encoding)
+    signature = hmac.new(
+        bytes(key) if exchange == 'bybit' else key,
+        data.encode(encoding=encoding),
+        digest_func
+    )
+    if exchange in {"huobi", "okx"}:
+        return base64.b64encode(signature.digest()).decode()
+    else:
+        return signature.hexdigest()
+
+def compose_htx_ws_auth(endpoint, exchange, api_key, api_secret):
+    _params = {
+        "accessKey": api_key,
+        "signatureMethod": "HmacSHA256",
+        "signatureVersion": "2.1",
+        "timestamp": str(datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S"))
+    }
+    signature_payload = (f"GET\n{urlparse(endpoint).hostname}\n{urlparse(endpoint).path}\n"
+                         f"{urlencode(_params)}")
+    signature = generate_signature(exchange, api_secret, signature_payload)
+    _params["authType"] = "api"
+    _params["signature"] = signature
+    return {
+        "action": "req",
+        "ch": "auth",
+        "params": _params
+    }
 
 # https://binance-docs.github.io/apidocs/websocket_api/en/#rate-limits
 class RateLimitInterval(Enum):
@@ -51,11 +71,11 @@ class RateLimitInterval(Enum):
 class UserWSS:
     __slots__ = (
         "init",
-        "method",
         "exchange",
         "endpoint",
         "_api_key",
         "_api_secret",
+        "signed",
         "_passphrase",
         "_ws",
         "_listen_key",
@@ -67,16 +87,17 @@ class UserWSS:
         "in_event",
         "_response_pool",
         "tasks",
+        "ping"
     )
 
-    def __init__(self, method, ws_id, exchange, endpoint, api_key, api_secret, passphrase=None):
+    def __init__(self, ws_id, exchange, endpoint, api_key, api_secret, signed, passphrase=None):
         self.init = True
-        self.method = method
         self.exchange = exchange
         self.endpoint = endpoint
         #
         self._api_key = api_key
         self._api_secret = api_secret
+        self.signed = signed
         self._passphrase = passphrase
         self._ws = None
         self._listen_key = None
@@ -88,6 +109,7 @@ class UserWSS:
         self.request_limit_reached = False
         self.in_event = asyncio.Event()
         self.tasks = set()
+        self.ping = 0
 
     def tasks_manage(self, coro, name=None):
         _t = asyncio.create_task(coro, name=name)
@@ -99,27 +121,39 @@ class UserWSS:
         async for msg in self._ws:
             # logger.info(f"_ws_listener: msg: {self.ws_id}: {msg}")
             if isinstance(msg, str):
-                res = await self._handle_msg(json.loads(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
-                    elif self.exchange == 'binance':
-                        self._response_pool[res.get('id')] = res.get('result')
-                    elif self.exchange in ['okx', 'bitfinex']:
-                        self._response_pool[res.get('id') or self.ws_id] = res.get('data') or res
-                    self.in_event.set()
-                await asyncio.sleep(0)
+                try:
+                    _msg = json.loads(msg)
+                except JSONDecodeError:
+                    logger.warning(f"UserWSS: {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
+                        elif self.exchange == 'binance':
+                            self._response_pool[res.get('id')] = res.get('result')
+                        elif self.exchange in {'okx', 'bitfinex'}:
+                            self._response_pool[res.get('id') or self.ws_id] = res.get('data') or res
+                        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()
 
     async def start_wss(self):
-        async for self._ws in websockets.client.connect(self.endpoint, logger=logger_ws):
+        async for self._ws in connect(
+                self.endpoint,
+                logger=logger,
+                ping_interval=None if self.exchange == 'huobi' else 20
+        ):
             try:
                 await self._ws_listener()
             except ConnectionClosed as ex:
-                if ex.code == 4000:
+                if ex.rcvd and ex.rcvd.code == 4000:
                     logger.info(f"WSS closed for {self.ws_id}")
                     break
                 else:
@@ -129,10 +163,10 @@ class UserWSS:
                     logger.warning(f"Restart WSS for {self.ws_id}")
                     continue
             except Exception as ex:
-                logger.error(f"WSS start_wss() other exception: {ex}")
+                logger.error(f"WSS start other exception: {ex}")
 
     async def ws_login(self):
-        res = await self.request('userDataStream.start', _api_key=True)
+        res = await self.request(CONST_WS_START, send_api_key=True)
         if res is None:
             logger.warning(f"UserWSS: Not 'logged in' for {self.ws_id}")
             raise ConnectionClosed(None, None)
@@ -140,37 +174,37 @@ class UserWSS:
             if self.exchange == 'binance':
                 self._listen_key = res.get('listenKey')
                 self.tasks_manage(self.heartbeat(), f"heartbeat-{self.ws_id}")
-            else:
-                self._listen_key = f"{int(time.time() * 1000)}{self.ws_id}"
+            elif 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}")
 
-    async def request(self, _method=None, _params=None, _api_key=False, _signed=False):
+    async def request(self, method, _params=None, send_api_key=False, _signed=False):
         """
         Construct and handling request/response to WS API endpoint, use a description of the methods on
         https://developers.binance.com/docs/binance-trading-api/websocket_api#request-format
         :return: result: {} or None if temporary Out-of-Service state
         """
-        method = _method or self.method
         if self.request_limit_reached:
             logger.warning(f"UserWSS {self.ws_id}: request limit reached, try later")
             return None
-        if method != 'userDataStream.start' and not self.operational_status:
+        if method != CONST_WS_START and not self.operational_status:
             logger.warning("UserWSS temporary in Out-of-Service state")
             return None
-        if method in ('order.place', 'order.cancelReplace', 'order') and not self.order_handling:
+        if method in ('order.place', 'order.cancelReplace', 'order', 'create-order') and not self.order_handling:
             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))}"
-        if self.exchange in ("okx", "bitfinex") and method == CONST_3:
+        if self.exchange in ("okx", "bitfinex", "huobi") and method == CONST_WS_START:
             _id = self.ws_id
         else:
-            _id = ''.join(e for e in r_id if e.isalnum())[-ID_LEN_LIMIT[self.exchange]:]
+            _id = ''.join(e for e in r_id if e.isalnum())[-ID_LEN_LIMIT.get(self.exchange, 64):]
         await self._ws.send(
-            json.dumps(self.compose_request(_id, _api_key, method, params, _signed))
+            json.dumps(self.compose_request(_id, send_api_key, method, params, _signed))
         )
         await asyncio.sleep(0)
         try:
@@ -193,20 +227,28 @@ class UserWSS:
             elif f"NoneResponse{self.ws_id}" in self._response_pool:
                 return self._response_pool.pop(f"NoneResponse{self.ws_id}", None)
 
-    def compose_request(self, _id, api_key, method, params, signed):
+    def compose_request(self, _id, send_api_key, method, params, signed):
         if self.exchange == "binance":
-            return self._compose_binance_request(_id, api_key, method, params, signed)
+            return self._compose_binance_request(_id, send_api_key, method, params, signed)
         elif self.exchange == "okx":
             return self._compose_okx_request(_id, method, params)
-        elif self.exchange == 'bitfinex':
+        elif self.exchange == "bitfinex":
             return self._compose_bitfinex_request(_id, method, params)
+        elif self.exchange == "huobi":
+            return self._compose_htx_request(_id, method, params)
         else:
             raise ValueError(f"Unsupported exchange: {self.exchange}")
 
-    def _compose_binance_request(self, _id, api_key, method, params, signed):
+    def _compose_htx_request(self, _id, method, params):
+        if method == CONST_WS_START:
+            return compose_htx_ws_auth(self.endpoint, self.exchange, self._api_key, self._api_secret)
+        else:
+            return {"cid": _id, "ch": method, "params": params}
+
+    def _compose_binance_request(self, _id, send_api_key, method, params, signed):
         req = {"id": _id, "method": method}
         params = params or {}
-        if api_key:
+        if send_api_key:
             params["apiKey"] = self._api_key
         if signed:
             params["timestamp"] = int(time.time() * 1000)
@@ -217,7 +259,7 @@ class UserWSS:
         return req
 
     def _compose_okx_request(self, _id, method, params):
-        if method == CONST_3:
+        if method == CONST_WS_START:
             ts = int(time.time())
             signature_payload = f"{ts}GET/users/self/verify"
             signature = generate_signature(self.exchange, self._api_secret, signature_payload)
@@ -231,7 +273,7 @@ class UserWSS:
             return {"id": _id, "op": method, "args": params if isinstance(params, list) else [params]}
 
     def _compose_bitfinex_request(self, _id, method, params):
-        if method == CONST_3:
+        if method == CONST_WS_START:
             ts = int(time.time() * 1000)
             data = f"AUTH{ts}"
             return {
@@ -265,10 +307,21 @@ class UserWSS:
             await self.request(
                 "userDataStream.ping",
                 params,
-                _api_key=True,
+                send_api_key=True,
             )
             await asyncio.sleep(interval)
 
+    async def htx_keepalive(self, interval=60):
+        await asyncio.sleep(interval * 10)
+        while True:
+            await asyncio.sleep(interval)
+            if self.ping:
+                break
+            else:
+                self.ping = 1
+        logger.warning("From HTX server PING timeout exceeded")
+        await self.stop()
+
     async def stop(self):
         """
         Stop data stream
@@ -278,7 +331,7 @@ class UserWSS:
         self.init = True
         [task.cancel() for task in self.tasks if not task.done()]
         self.tasks.clear()
-        if self._ws and not self._ws.closed:
+        if self._ws:
             await self._ws.close(code=4000)
         gc.collect()
         logger.info(f"User WSS for {self.ws_id} stopped")
@@ -292,11 +345,37 @@ class UserWSS:
             return msg
         elif self.exchange == 'okx':
             if msg.get('code') != '0':
-                await self.okx_error_handle(msg)
+                self.okx_error_handle(msg)
                 msg = None
             return msg
         elif self.exchange == 'bitfinex':
             return await self.bitfinex_error_handle(msg)
+        elif self.exchange == 'huobi':
+            if msg.get('action') == 'ping':
+                pong = {
+                    "action": "pong",
+                    "data": {
+                        "ts": msg.get('data').get('ts')
+                    }
+                }
+                self.ping = 0
+                await self._ws.send(json.dumps(pong))
+                return 'pass'
+
+            if msg.get('code') == 200 or msg.get('status') == 'ok':
+                return msg
+
+            await self.htx_error_handle(msg)
+
+    async def htx_error_handle(self, msg):
+        if msg.get('code') == 500:
+            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}")
+        else:
+            logger.warning(f"Malformed request: status: {msg}")
 
     # region BitfinexErrorHandle
     async def bitfinex_error_handle(self, msg):
@@ -314,7 +393,7 @@ class UserWSS:
         elif event == 'auth':
             return msg if msg.get('status') == "OK" else None
         elif msg.get('code'):
-            return await self._handle_error_code(msg)
+            return self._handle_error_code(msg)
         return 'pass'
 
     async def _handle_info_event(self, msg):
@@ -325,7 +404,7 @@ class UserWSS:
             logger.critical('Bitfinex WSS platform: version change detected')
         return 'pass'
 
-    async def _handle_error_code(self, msg):
+    def _handle_error_code(self, msg):
         code = msg.get('code')
         if code == 10305:
             logger.warning('UserWSS Bitfinex: Reached limit of open channels')
@@ -333,7 +412,6 @@ class UserWSS:
             self.request_limit_reached = True
         else:
             logger.warning(f"Malformed request for {self.ws_id}: {msg}")
-        return None
 
     @staticmethod
     def _transform_list_message(msg):
@@ -352,15 +430,16 @@ class UserWSS:
         }
     # endregion
 
-    async def okx_error_handle(self, msg):
+    def okx_error_handle(self, msg):
         if msg.get('code') == '1':
-            logger.warning(f"Operation failed: {msg}")
+            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}")
         elif msg.get('code') == '60014':
             self._retry_after = int((time.time() + TIMEOUT) * 1000)
             self.request_limit_reached = True
-        logger.warning(f"Malformed request: status: {msg}")
+        else:
+            logger.warning(f"Malformed request: status: {msg}")
 
     async def binance_error_handle(self, msg):
         error_msg = msg.get('error')
@@ -396,7 +475,7 @@ class UserWSSession:
     )
 
     def __init__(self, exchange, endpoint, api_key, api_secret, passphrase=None):
-        if exchange not in ('binance', 'okx', 'bitfinex'):
+        if exchange not in ('binance', 'okx', 'bitfinex', 'huobi'):
             raise UserWarning(f"UserWSSession: exchange {exchange} not serviced")
         self.exchange = exchange
         self.endpoint = endpoint
@@ -412,19 +491,20 @@ class UserWSSession:
         trade_id: str,
         method: str,
         _params=None,
-        _api_key=False,
+        send_api_key=False,
         _signed=False,
     ):
         ws_id = f"{self.exchange}-{trade_id}-{method}"
+
         user_wss = self.user_wss.setdefault(
             ws_id,
             UserWSS(
-                method,
                 ws_id,
                 self.exchange,
                 self.endpoint,
                 self._api_key,
                 self._api_secret,
+                _signed,
                 self._passphrase
             )
         )
@@ -444,7 +524,7 @@ class UserWSSession:
             duration += DELAY
 
         try:
-            return await user_wss.request(_params=_params, _api_key=_api_key, _signed=_signed)
+            return await user_wss.request(method=method, _params=_params, send_api_key=send_api_key, _signed=_signed)
         except asyncio.CancelledError:
             pass  # Task cancellation should not be logged as an error
         except Exception as ex:

{crypto-ws-api-2.0.13 → crypto_ws_api-2.0.15}/pyproject.toml

@@ -17,10 +17,10 @@ dynamic = ["version", "description"]
 requires-python = ">=3.8"
 
 dependencies = [
-    "shortuuid~=1.0.11",
-    "platformdirs~=3.10.0",
+    "shortuuid~=1.0.13",
+    "platformdirs==3.11.0",
     "toml~=0.10.2",
-    "websockets~=12.0",
+    "websockets==14.1",
     "ujson~=5.10.0"
 ]
 

{crypto-ws-api-2.0.13 → crypto_ws_api-2.0.15}/requirements.txt

@@ -1,5 +1,5 @@
 shortuuid~=1.0.13
 platformdirs==3.11.0
 toml~=0.10.2
-websockets==13.0.1
+websockets==14.1
 ujson~=5.10.0