exchanges-wrapper 2.1.27__tar.gz → 2.1.29__tar.gz

{exchanges_wrapper-2.1.27 → exchanges_wrapper-2.1.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: exchanges-wrapper
-Version: 2.1.27
+Version: 2.1.29
 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.9

{exchanges_wrapper-2.1.27 → exchanges_wrapper-2.1.29}/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.27"
+__version__ = "2.1.29"
 
 from pathlib import Path
 import shutil

{exchanges_wrapper-2.1.27 → exchanges_wrapper-2.1.29}/exchanges_wrapper/client.py

@@ -472,13 +472,15 @@ class Client:
                 'status': 'SUCCESS',
                 'startTime': max(self.ts_start[symbol], (int(time.time()) - 300) * 1000)
             }
+            _res = []
             # Internal transfer, ie from Funding to UTA account
             res, ts = await self.http.send_api_call(
                 "/v5/asset/transfer/query-inter-transfer-list",
                 signed=True,
                 **params
             )
-            _res = bbt.on_balance_update(res['list'], ts, symbol, 'internal')
+            if res:
+                _res = bbt.on_balance_update(res['list'], ts, symbol, 'internal')
 
             # Universal Transfer Records, ie from Sub account to Main account
             res, ts = await self.http.send_api_call(
@@ -486,13 +488,14 @@ class Client:
                 signed=True,
                 **params
             )
-            _res += bbt.on_balance_update(
-                res['list'],
-                ts,
-                symbol,
-                'universal',
-                uid=self.account_uid
-            )
+            if res:
+                _res += bbt.on_balance_update(
+                    res['list'],
+                    ts,
+                    symbol,
+                    'universal',
+                    uid=self.account_uid
+                )
 
             if not _res:
                 # Get Transaction Log
@@ -506,12 +509,13 @@ class Client:
                     signed=True,
                     **params
                 )
-                _res += bbt.on_balance_update(
-                    res['list'],
-                    ts,
-                    symbol,
-                    'log'
-                )
+                if res:
+                    _res += bbt.on_balance_update(
+                        res['list'],
+                        ts,
+                        symbol,
+                        'log'
+                    )
 
             for i in _res:
                 _id = next(iter(i))
@@ -1005,11 +1009,13 @@ class Client:
         elif self.exchange == 'bybit':
             params = {
                 'category': 'spot',
-                'symbol': symbol,
-                'orderId': str(order_id),
-                'orderLinkId': str(origin_client_order_id),
+                'symbol': symbol
             }
-            res, _ = await self.http.send_api_call("/v5/order/history", signed=True, **params)
+            if order_id:
+                params['orderId'] = str(order_id)
+            else:
+                params['orderLinkId'] = str(origin_client_order_id)
+            res, _ = await self.http.send_api_call("/v5/order/realtime", signed=True, **params)
             if res["list"]:
                 b_res = bbt.order(res["list"][0], response_type=response_type)
         return b_res
@@ -1311,7 +1317,7 @@ class Client:
         elif self.exchange == 'bybit':
             params = {'category': 'spot', 'symbol': symbol}
             res, _ = await self.http.send_api_call("/v5/order/realtime", signed=True, **params)
-            binance_res = bbt.orders(res['list'], response_type=response_type)
+            binance_res = bbt.orders(res.get('list', []), response_type=response_type)
         return binance_res
 
     # https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#all-orders-user_data

{exchanges_wrapper-2.1.27 → exchanges_wrapper-2.1.29}/exchanges_wrapper/exch_srv.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
+from typing import Any, AsyncGenerator
 
 import grpclib.exceptions
 
@@ -25,6 +26,9 @@ from exchanges_wrapper.lib import (
     REST_RATE_LIMIT_INTERVAL,
     FILTER_TYPE_MAP,
 )
+from exchanges_wrapper.martin import StreamResponse, SimpleResponse, OnKlinesUpdateResponse, OnTickerUpdateResponse, \
+    FetchOrderBookResponse
+
 #
 HEARTBEAT = 1  # sec
 MAX_QUEUE_SIZE = 100
@@ -154,12 +158,13 @@ class Martin(mr.MartinBase):
     async def reset_rate_limit(self, request: mr.OpenClientConnectionId) -> mr.SimpleResponse:
         Martin.rate_limiter = max(Martin.rate_limiter or 0, request.rate_limiter)
         _success = False
-        client = OpenClient.get_client(request.client_id).client
+        open_client = OpenClient.get_client(request.client_id)
+        client = open_client.client
         if Martin.rate_limit_reached_time:
             if time.time() - Martin.rate_limit_reached_time > 30:
                 client.http.rate_limit_reached = False
                 Martin.rate_limit_reached_time = None
-                logger.info("RateLimit error clear, trying one else time")
+                logger.info(f"RateLimit error clear for {open_client.name}, trying one else time")
                 _success = True
         elif client.http.rate_limit_reached:
             Martin.rate_limit_reached_time = time.time()
@@ -434,7 +439,7 @@ class Martin(mr.MartinBase):
         response.items = list(map(json.dumps, res))
         return response
 
-    async def on_klines_update(self, request: mr.FetchKlinesRequest) -> mr.OnKlinesUpdateResponse:
+    async def on_klines_update(self, request: mr.FetchKlinesRequest) -> AsyncGenerator[OnKlinesUpdateResponse, Any]:
         response = mr.OnKlinesUpdateResponse()
         open_client = OpenClient.get_client(request.client_id)
         client = open_client.client
@@ -508,7 +513,7 @@ class Martin(mr.MartinBase):
         response.items = list(map(json.dumps, res))
         return response
 
-    async def on_ticker_update(self, request: mr.MarketRequest) -> mr.OnTickerUpdateResponse:
+    async def on_ticker_update(self, request: mr.MarketRequest) -> AsyncGenerator[OnTickerUpdateResponse, Any]:
         response = mr.OnTickerUpdateResponse()
         open_client = OpenClient.get_client(request.client_id)
         client = open_client.client
@@ -543,7 +548,7 @@ class Martin(mr.MartinBase):
                 yield response
                 _queue.task_done()
 
-    async def on_order_book_update(self, request: mr.MarketRequest) -> mr.FetchOrderBookResponse:
+    async def on_order_book_update(self, request: mr.MarketRequest) -> AsyncGenerator[FetchOrderBookResponse, Any]:
         response = mr.FetchOrderBookResponse()
         open_client = OpenClient.get_client(request.client_id)
         client = open_client.client
@@ -577,7 +582,7 @@ class Martin(mr.MartinBase):
                     yield response
                 _queue.task_done()
 
-    async def on_funds_update(self, request: mr.OnFundsUpdateRequest) -> mr.StreamResponse:
+    async def on_funds_update(self, request: mr.OnFundsUpdateRequest) -> AsyncGenerator[StreamResponse, Any]:
         response = mr.StreamResponse()
         open_client = OpenClient.get_client(request.client_id)
         client = open_client.client
@@ -597,7 +602,7 @@ class Martin(mr.MartinBase):
                 yield response
                 _queue.task_done()
 
-    async def on_balance_update(self, request: mr.MarketRequest) -> mr.StreamResponse:
+    async def on_balance_update(self, request: mr.MarketRequest) -> AsyncGenerator[StreamResponse, Any]:
         response = mr.StreamResponse()
         open_client = OpenClient.get_client(request.client_id)
         client = open_client.client
@@ -640,10 +645,10 @@ class Martin(mr.MartinBase):
                     response.event = json.dumps(balance)
                     yield response
 
-                if _get_event_from_queue:
-                    _queue.task_done()
+            if _get_event_from_queue:
+                _queue.task_done()
 
-    async def on_order_update(self, request: mr.MarketRequest) -> mr.SimpleResponse:
+    async def on_order_update(self, request: mr.MarketRequest) -> AsyncGenerator[SimpleResponse, Any]:
         response = mr.SimpleResponse()
         open_client = OpenClient.get_client(request.client_id)
         client = open_client.client
@@ -787,6 +792,7 @@ class Martin(mr.MartinBase):
         OpenClient.remove_client(request.account_name)
         return mr.SimpleResponse(success=True)
 
+
 async def stop_stream(client, trade_id):
     await client.stop_events_listener(trade_id)
     client.events.unregister(client.exchange, trade_id)
@@ -808,6 +814,7 @@ async def event_handler(_queue, client, trade_id, _event_type, event):
         MAX_QUEUE_SIZE += int(MAX_QUEUE_SIZE / 10)
         logger.info(f"MAX_QUEUE_SIZE was updated: new value is {MAX_QUEUE_SIZE}")
 
+
 def is_port_in_use(port: int) -> bool:
     import socket
     with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:

{exchanges_wrapper-2.1.27 → exchanges_wrapper-2.1.29}/exchanges_wrapper/exch_srv_cfg.toml.template

@@ -1,6 +1,6 @@
 # Parameters for exchanges-wrapper REST API Server exch_srv.py
 # Copyright © 2021-2025 Jerry Fedorenko aka VM
-# __version__ = "2.1.21"
+# __version__ = "2.1.29"
 # region endpoint
 [endpoint]
     [endpoint.binance]
@@ -38,12 +38,12 @@
         ws_api = 'wss://api.huobi.pro/ws/trade'
 
     [endpoint.okx]
-        api_public = 'https://aws.okx.com'
-        api_auth = 'https://aws.okx.com'
-        ws_public = 'wss://wsaws.okx.com:8443/ws/v5/public'
-        ws_auth = 'wss://wsaws.okx.com:8443/ws/v5/private'
+        api_public = 'https://www.okx.com'
+        api_auth = 'https://www.okx.com'
+        ws_public = 'wss://ws.okx.com:8443/ws/v5/public'
+        ws_auth = 'wss://ws.okx.com:8443/ws/v5/private'
         ws_business = 'wss://ws.okx.com:8443/ws/v5/business'
-        api_test = 'https://aws.okx.com'
+        api_test = 'https://www.okx.com'
         ws_test = 'wss://wspap.okx.com:8443/ws/v5/private?brokerId=9999'
 
     [endpoint.bybit]

{exchanges_wrapper-2.1.27 → exchanges_wrapper-2.1.29}/exchanges_wrapper/http_client.py

@@ -15,6 +15,9 @@ from exchanges_wrapper.errors import (
     HTTPError,
     QueryCanceled,
 )
+from exchanges_wrapper.parsers.bybit import RateLimitHandler
+
+
 logger = logging.getLogger(__name__)
 
 AJ = 'application/json'
@@ -39,6 +42,7 @@ class HttpClient:
         self._session_mutex = asyncio.Lock()
         self.ex_imps = {}  #  exchanges implementation
         self.declare_exchanges_implementation()
+        self.rate_limit_handler = RateLimitHandler() if self.exchange == 'bybit' else None
 
     def declare_exchanges_implementation(self):
         # noinspection PyTypeChecker
@@ -55,15 +59,15 @@ class HttpClient:
             async with self._session_mutex:
                 self.session = aiohttp.ClientSession(timeout=TIMEOUT)
 
-    async def handle_errors(self, response):
+    async def handle_errors(self, response, path=None):
         if response.status >= 500:
             raise ExchangeError(
                 f"{'API request rejected' if self.exchange == 'bitfinex' else 'An issue occurred on exchange side'}:"
                 f" {response.status}: {response.url}: {response.reason}"
             )
-        if response.status == 429:
+        if response.status == 429 or (self.exchange == 'bybit' and response.status == STATUS_FORBIDDEN):
             logger.error(f"API RateLimitReached: {response.url}")
-            self.rate_limit_reached = self.exchange in ('binance', 'okx')
+            self.rate_limit_reached = self.exchange in ('binance', 'okx', 'bybit')
             raise RateLimitReached(RateLimitReached.message)
 
         try:
@@ -75,6 +79,7 @@ class HttpClient:
             if response.status == STATUS_BAD_REQUEST:
                 if payload:
                     if payload.get("error", "") == "ERR_RATE_LIMIT":
+                        self.rate_limit_reached = True
                         raise RateLimitReached(RateLimitReached.message)
                     elif self.exchange == 'binance' and payload.get('code', 0) == -1021:
                         raise ExchangeError(ERR_TIMESTAMP_OUTSIDE_RECV_WINDOW)
@@ -102,6 +107,10 @@ class HttpClient:
                 return payload.get('result'), payload.get('time')
             elif payload.get('retCode') == 10002:
                 raise ExchangeError(ERR_TIMESTAMP_OUTSIDE_RECV_WINDOW)
+            elif payload.get('retCode') == 10006:
+                self.rate_limit_handler.fire_exceeded_rate_limit(path)
+                logger.warning(f"ByBit API: {payload.get('retMsg')}")
+                return payload.get('result'), payload.get('time')
             else:
                 raise ExchangeError(f"API request failed: {response.status}:{response.reason}:{payload}")
         elif self.exchange == 'huobi' and payload and (payload.get('status') == 'ok' or payload.get('ok')):
@@ -126,10 +135,14 @@ class HttpClient:
             raise QueryCanceled(QueryCanceled.message)
         return await self.ex_imps[self.exchange](path, method, signed, send_api_key, endpoint, timeout, **kwargs)
 
-    async def send_request(self, method, url, timeout, query_kwargs):
+    async def send_request(self, method, url, timeout, query_kwargs, path=None):
         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)
         except (aiohttp.ClientConnectionError, asyncio.exceptions.TimeoutError):
             await self.session.close()
@@ -184,6 +197,8 @@ class HttpClient:
         return await self.send_request(method, url, timeout, query_kwargs)
 
     async def _bybit_request(self, path, method, signed, _send_api_key, endpoint, timeout, **kwargs):
+        await self.rate_limit_handler.wait(path)
+
         url = endpoint or self.endpoint
         query_kwargs = {}
         data = None
@@ -214,7 +229,7 @@ class HttpClient:
 
         query_kwargs['data'] = data
         query_kwargs['headers'] = headers
-        return await self.send_request(method, url, timeout, query_kwargs)
+        return await self.send_request(method, url, timeout, query_kwargs, path)
 
     async def _huobi_request(self, path, method, signed, _send_api_key, endpoint, timeout, **kwargs):
         _endpoint = endpoint or self.endpoint

{exchanges_wrapper-2.1.27 → exchanges_wrapper-2.1.29}/exchanges_wrapper/parsers/bybit.py

@@ -1,6 +1,9 @@
 """
 Parser for convert Bybit REST API/WSS V5 response to Binance like result
 """
+import asyncio
+import random
+import time
 from decimal import Decimal
 import logging
 
@@ -49,6 +52,57 @@ class OrderBook:
         # return self
 
 
+class RateLimitHandler:
+    def __init__(self):
+        self.stats = {}  # {'path': [limit_status, start_time, reset_time, range_window, limit]}
+
+    def update(self, path, headers):
+        if limit := int(headers.get('X-Bapi-Limit', '0')):
+            limit_status = int(headers['X-Bapi-Limit-Status'])
+            now = int(time.time() * 1000)
+            reset_time = max(int(headers['X-Bapi-Limit-Reset-Timestamp']), now)
+            if stats := self.stats.get(path):
+                _limit_status, start_time, _reset_time, _range_window, _limit = stats
+            else:
+                _limit_status = limit_status
+                start_time = now
+                _range_window = 1000
+            if limit_status == limit - 1:
+                start_time = now
+                range_window = max(_range_window, 1000)
+            else:
+                range_window = max(_range_window, now - start_time)
+                n = (_limit_status - limit_status) if _limit_status > limit_status else 1
+                reset_time += n * range_window / limit
+            self.stats[path] = [limit_status, start_time, reset_time, range_window, limit]
+
+    async def wait(self, path):
+        if self.stats.get(path) is None:
+            return
+        limit_status, start_time, reset_time, range_window, limit = self.stats[path]
+        min_delay = range_window / limit
+        now = int(time.time() * 1000)
+        if limit_status <= 1:
+            delay = max(
+                random.randint(1000, 2000),  #NOSONAR python:S2245
+                max(reset_time, start_time + range_window) - now
+            ) / 1000
+        else:
+            delay = max(min_delay, reset_time - now) / 1000
+        await asyncio.sleep(delay)
+
+    def fire_exceeded_rate_limit(self, path):
+        if stats := self.stats.get(path):
+            limit_status, start_time, _reset_time, range_window, limit = stats
+            self.stats[path] = [
+                limit_status,
+                start_time,
+                int(time.time() * 1000) + range_window,
+                range_window,
+                limit
+            ]
+
+
 def fetch_server_time(res: dict) -> dict:
     return {'serverTime': int(res['timeNano']) // 1000000}