exchanges-wrapper 2.1.52__tar.gz → 2.2.4__tar.gz

{exchanges_wrapper-2.1.52 → exchanges_wrapper-2.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: exchanges-wrapper
-Version: 2.1.52
+Version: 2.2.4
 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.12
@@ -12,9 +12,8 @@ Classifier: Operating System :: Unix
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: MacOS
 License-File: LICENSE.md
-Requires-Dist: crypto-ws-api==2.1.12
+Requires-Dist: crypto-ws-api==2.1.15
 Requires-Dist: pyotp==2.10.0
-Requires-Dist: simplejson==4.1.1
 Requires-Dist: aiohttp==3.14.3
 Requires-Dist: expiringdict==1.2.2
 Requires-Dist: betterproto==2.0.0b7

{exchanges_wrapper-2.1.52 → exchanges_wrapper-2.2.4}/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.52"
+__version__ = "2.2.4"
 
 from pathlib import Path
 import shutil

{exchanges_wrapper-2.1.52 → exchanges_wrapper-2.2.4}/exchanges_wrapper/exch_srv.py

@@ -16,8 +16,7 @@ import gc
 import traceback
 import asyncio
 import functools
-# noinspection PyPackageRequirements
-import ujson as json
+import orjson
 import logging
 from decimal import Decimal
 import ctypes, ctypes.util
@@ -162,7 +161,7 @@ class Martin(mr.MartinBase):
             real_market=open_client.real_market
         )
 
-    async def reset_rate_limit(self, request: mr.OpenClientConnectionId) -> mr.SimpleResponse:
+    async def reset_rate_limit(self, request: mr.OpenClientConnectionId) -> SimpleResponse:
         Martin.rate_limiter = max(Martin.rate_limiter or 0, request.rate_limiter)
         _success = False
         open_client = OpenClient.get_client(request.client_id)
@@ -175,7 +174,7 @@ class Martin(mr.MartinBase):
                 _success = True
         elif client.http.rate_limit_reached:
             Martin.rate_limit_reached_time = time.time()
-        return mr.SimpleResponse(success=_success)
+        return SimpleResponse(success=_success)
 
     async def send_request(self, client_method_name, request, rate_limit=False, **kwargs):
         open_client_instance = OpenClient.get_client(request.client_id)
@@ -233,9 +232,9 @@ class Martin(mr.MartinBase):
         server_time = res.get('serverTime')
         return mr.FetchServerTimeResponse(server_time=server_time)
 
-    async def one_click_arrival_deposit(self, request: mr.MarketRequest) -> mr.SimpleResponse:
+    async def one_click_arrival_deposit(self, request: mr.MarketRequest) -> SimpleResponse:
         res, _, _ = await self.send_request('one_click_arrival_deposit', request, tx_id=request.symbol)
-        return mr.SimpleResponse(success=True, result=json.dumps(str(res)))
+        return SimpleResponse(success=True, result=orjson.dumps(res))
 
     async def fetch_open_orders(self, request: mr.MarketRequest) -> mr.FetchOpenOrdersResponse:
         response = mr.FetchOpenOrdersResponse()
@@ -248,7 +247,7 @@ class Martin(mr.MartinBase):
         )
         for order in res:
             order_id = order['orderId']
-            response.orders.append(json.dumps(order))
+            response.orders.append(orjson.dumps(order))
             if client.exchange in ('bitfinex', 'huobi'):
                 client.active_order(order_id, order['origQty'], order['executedQty'])
 
@@ -302,8 +301,8 @@ class Martin(mr.MartinBase):
             await _queue.put(weakref.ref(event)())
         logger.debug(f"{msg_header}: {trades}")
 
-    async def cancel_all_orders(self, request: mr.MarketRequest) -> mr.SimpleResponse:
-        response = mr.SimpleResponse()
+    async def cancel_all_orders(self, request: mr.MarketRequest) -> SimpleResponse:
+        response = SimpleResponse()
 
         res, _, _ = await self.send_request(
             'cancel_all_orders',
@@ -313,7 +312,7 @@ class Martin(mr.MartinBase):
         )
 
         response.success = True
-        response.result = json.dumps(str(res))
+        response.result = orjson.dumps(res)
         return response
 
     async def fetch_exchange_info_symbol(self, request: mr.MarketRequest) -> mr.FetchExchangeInfoSymbolResponse:
@@ -353,8 +352,8 @@ class Martin(mr.MartinBase):
                 setattr(filters, filter_type.lower(), filter_instance)
         return filters
 
-    async def fetch_account_information(self, request: mr.OpenClientConnectionId) -> mr.JsonResponse:
-        response = mr.JsonResponse()
+    async def fetch_account_information(self, request: mr.OpenClientConnectionId) -> mr.BytesResponse:
+        response = mr.BytesResponse()
         account_information, _, _ = await self.send_request(
             'fetch_account_information',
             request,
@@ -363,17 +362,21 @@ class Martin(mr.MartinBase):
         )
         # Send only balances
         res = account_information.get('balances', [])
-        balances = [
-            {'asset': i['asset'], 'free': i['free'], 'locked': i['locked']}
-            for i in res if Decimal(i['free']) or Decimal(i['locked'])
-        ]
-        response.items = list(map(json.dumps, balances))
+        response.items.extend(
+            orjson.dumps({
+                'asset': i['asset'],
+                'free': i['free'],
+                'locked': i['locked']
+            })
+            for i in res
+            if float(i['free']) or float(i['locked'])
+        )
         return response
 
-    async def fetch_funding_wallet(self, request: mr.FetchFundingWalletRequest) -> mr.JsonResponse:
+    async def fetch_funding_wallet(self, request: mr.FetchFundingWalletRequest) -> mr.BytesResponse:
         open_client = OpenClient.get_client(request.client_id)
         client = open_client.client
-        response = mr.JsonResponse()
+        response = mr.BytesResponse()
         res = []
         if client.exchange in ('bitfinex', 'okx', 'bybit') \
                 or (open_client.real_market and client.exchange == 'binance'):
@@ -384,7 +387,7 @@ class Martin(mr.MartinBase):
                 asset=request.asset,
                 need_btc_valuation=request.need_btc_valuation
             )
-        response.items = list(map(json.dumps, res))
+        response.items.extend(orjson.dumps(item) for item in res)
         return response
 
     async def fetch_order_book(self, request: mr.MarketRequest) -> mr.FetchOrderBookResponse:
@@ -396,9 +399,10 @@ class Martin(mr.MartinBase):
             symbol=request.symbol
         )
 
-        res['bids'] = [json.dumps(v) for v in res.get('bids', [])]
-        res['asks'] = [json.dumps(v) for v in res.get('asks', [])]
-        return response.from_pydict(res)
+        response.last_update_id = res.get('lastUpdateId', 0)
+        response.bids.extend(orjson.dumps(v) for v in res.get('bids', []))
+        response.asks.extend(orjson.dumps(v) for v in res.get('asks', []))
+        return response
 
     async def fetch_symbol_price_ticker(self, request: mr.MarketRequest) -> mr.FetchSymbolPriceTickerResponse:
         response = mr.FetchSymbolPriceTickerResponse()
@@ -423,8 +427,8 @@ class Martin(mr.MartinBase):
         )
         return response.from_pydict(res)
 
-    async def fetch_klines(self, request: mr.FetchKlinesRequest) -> mr.JsonResponse:
-        response = mr.JsonResponse()
+    async def fetch_klines(self, request: mr.FetchKlinesRequest) -> mr.BytesResponse:
+        response = mr.BytesResponse()
 
         res, _, _ = await self.send_request(
             'fetch_klines',
@@ -437,16 +441,16 @@ class Martin(mr.MartinBase):
             limit=request.limit
         )
 
-        response.items = list(map(json.dumps, res))
+        response.items.extend(orjson.dumps(item) for item in res)
         return response
 
     async def on_klines_update(self, request: mr.FetchKlinesRequest) -> AsyncGenerator[OnKlinesUpdateResponse, Any]:
-        response = mr.OnKlinesUpdateResponse()
+        response = OnKlinesUpdateResponse()
         open_client = OpenClient.get_client(request.client_id)
         client = open_client.client
         _queue = asyncio.Queue(MAX_QUEUE_SIZE)
         client.stream_queue[request.trade_id] |= {_queue}
-        _intervals = json.loads(request.interval)
+        _intervals = orjson.loads(request.intervals)
         event_types = []
         # Register streams for intervals
         if client.exchange == 'bitfinex':
@@ -474,29 +478,31 @@ class Martin(mr.MartinBase):
                 logger.info(f"OnKlinesUpdate: Stop loop for {open_client.name}:{request.symbol}:{_intervals}")
                 return
             else:
-                # logger.info(f"OnKlinesUpdate.event: {exchange}:{_event.symbol}:{_event.kline_interval}")
-                response.symbol = _event.symbol
-                response.interval = _event.kline_interval
-                response.candle = json.dumps(
-                    [_event.kline_start_time,
-                     _event.kline_open_price,
-                     _event.kline_high_price,
-                     _event.kline_low_price,
-                     _event.kline_close_price,
-                     _event.kline_base_asset_volume,
-                     _event.kline_close_time,
-                     _event.kline_quote_asset_volume,
-                     _event.kline_trades_number,
-                     _event.kline_taker_buy_base_asset_volume,
-                     _event.kline_taker_buy_quote_asset_volume,
-                     _event.kline_ignore
-                     ]
-                )
+                ev = _event
+
+                response.symbol = ev.symbol
+                response.interval = ev.kline_interval
+                response.candle = b""
+                response.candle = orjson.dumps([
+                    ev.kline_start_time,
+                    ev.kline_open_price,
+                    ev.kline_high_price,
+                    ev.kline_low_price,
+                    ev.kline_close_price,
+                    ev.kline_base_asset_volume,
+                    ev.kline_close_time,
+                    ev.kline_quote_asset_volume,
+                    ev.kline_trades_number,
+                    ev.kline_taker_buy_base_asset_volume,
+                    ev.kline_taker_buy_quote_asset_volume,
+                    ev.kline_ignore
+                ])
+
                 yield response
                 _queue.task_done()
 
-    async def fetch_account_trade_list(self, request: mr.AccountTradeListRequest) -> mr.JsonResponse:
-        response = mr.JsonResponse()
+    async def fetch_account_trade_list(self, request: mr.AccountTradeListRequest) -> mr.BytesResponse:
+        response = mr.BytesResponse()
 
         res, _, _ = await self.send_request(
             'fetch_account_trade_list',
@@ -510,11 +516,11 @@ class Martin(mr.MartinBase):
             limit=request.limit
         )
 
-        response.items = list(map(json.dumps, res))
+        response.items.extend(orjson.dumps(item) for item in res)
         return response
 
     async def on_ticker_update(self, request: mr.MarketRequest) -> AsyncGenerator[OnTickerUpdateResponse, Any]:
-        response = mr.OnTickerUpdateResponse()
+        response = OnTickerUpdateResponse()
         open_client = OpenClient.get_client(request.client_id)
         client = open_client.client
         _queue = asyncio.Queue(MAX_QUEUE_SIZE)
@@ -540,18 +546,18 @@ class Martin(mr.MartinBase):
                 return
             else:
                 Martin.ticker_update_time[request.trade_id] = time.time()
-                response.from_pydict(
-                    {
-                        'openPrice': _event.open_price,
-                        'lastPrice': _event.close_price,
-                        'closeTime': _event.event_time
-                    }
-                )
+                ev = _event
+                response.open_price = ""
+                response.last_price = ""
+                response.open_price = str(ev.open_price)
+                response.last_price = str(ev.close_price)
+                response.close_time = int(ev.event_time)
+
                 yield response
                 _queue.task_done()
 
     async def on_order_book_update(self, request: mr.MarketRequest) -> AsyncGenerator[FetchOrderBookResponse, Any]:
-        response = mr.FetchOrderBookResponse()
+        response = FetchOrderBookResponse()
         open_client = OpenClient.get_client(request.client_id)
         client = open_client.client
         _queue = asyncio.LifoQueue(MAX_QUEUE_SIZE * 5)
@@ -577,15 +583,26 @@ class Martin(mr.MartinBase):
                 logger.info(f"OnOrderBookUpdate: Stop loop for {open_client.name}: {request.symbol}")
                 return
             else:
-                if _event.bids and _event.asks:
+                event_bids = _event.bids
+                event_asks = _event.asks
+
+                if event_bids and event_asks:
                     response.last_update_id = _event.last_update_id
-                    response.bids = list(map(json.dumps, _event.bids))
-                    response.asks = list(map(json.dumps, _event.asks))
+
+                    res_bids = response.bids
+                    res_asks = response.asks
+
+                    res_bids.clear()
+                    res_asks.clear()
+
+                    res_bids.extend(orjson.dumps(v) for v in event_bids)
+                    res_asks.extend(orjson.dumps(v) for v in event_asks)
+
                     yield response
                 _queue.task_done()
 
     async def on_funds_update(self, request: mr.OnFundsUpdateRequest) -> AsyncGenerator[StreamResponse, Any]:
-        response = mr.StreamResponse()
+        response = StreamResponse()
         open_client = OpenClient.get_client(request.client_id)
         client = open_client.client
         _queue = asyncio.Queue(MAX_QUEUE_SIZE)
@@ -600,12 +617,13 @@ class Martin(mr.MartinBase):
                 logger.info(f"OnFundsUpdate: Stop user stream for {open_client.name}: {request.symbol}")
                 return
             else:
-                response.event = json.dumps(_event.balances)
+                response.event = b""
+                response.event = orjson.dumps(_event.balances)
                 yield response
                 _queue.task_done()
 
     async def on_balance_update(self, request: mr.MarketRequest) -> AsyncGenerator[StreamResponse, Any]:
-        response = mr.StreamResponse()
+        response = StreamResponse()
         open_client = OpenClient.get_client(request.client_id)
         client = open_client.client
         _queue = asyncio.Queue(MAX_QUEUE_SIZE)
@@ -637,21 +655,26 @@ class Martin(mr.MartinBase):
                     [_events.append(client.events.wrap_event(balance)) for balance in balances]
 
             for _event in _events:
-                if _event.asset in request.symbol:
+                ev = _event
+                ev_asset = ev.asset
+
+                if ev_asset in request.symbol:
                     balance = {
-                        "event_time": _event.event_time,
-                        "asset": _event.asset,
-                        "balance_delta": _event.balance_delta,
-                        "clear_time": _event.clear_time
+                        "event_time": ev.event_time,
+                        "asset": ev_asset,
+                        "balance_delta": ev.balance_delta,
+                        "clear_time": ev.clear_time
                     }
-                    response.event = json.dumps(balance)
+
+                    response.event = b""
+                    response.event = orjson.dumps(balance)
                     yield response
 
             if _get_event_from_queue:
                 _queue.task_done()
 
     async def on_order_update(self, request: mr.MarketRequest) -> AsyncGenerator[SimpleResponse, Any]:
-        response = mr.SimpleResponse()
+        response = SimpleResponse()
         open_client = OpenClient.get_client(request.client_id)
         client = open_client.client
         _queue = asyncio.Queue(MAX_QUEUE_SIZE)
@@ -667,10 +690,12 @@ class Martin(mr.MartinBase):
                 logger.info(f"OnOrderUpdate: Stop user stream for {open_client.name}: {request.symbol}")
                 return
             else:
-                event = vars(_event)
-                event.pop('handlers', None)
+                event_dict = _event.__dict__.copy()
+                event_dict.pop('handlers', None)
+                response.result = b""
                 response.success = True
-                response.result = json.dumps(event)
+                response.result = orjson.dumps(event_dict)
+
                 yield response
                 _queue.task_done()
 
@@ -713,8 +738,8 @@ class Martin(mr.MartinBase):
         response.from_pydict(res)
         return response
 
-    async def transfer_to_sub(self, request: mr.MarketRequest) -> mr.SimpleResponse:
-        response = mr.SimpleResponse()
+    async def transfer_to_sub(self, request: mr.MarketRequest) -> SimpleResponse:
+        response = SimpleResponse()
         response.success = False
 
         res, _, _ = await self.send_request(
@@ -728,11 +753,11 @@ class Martin(mr.MartinBase):
 
         if res and res.get("txnId"):
             response.success = True
-        response.result = json.dumps(res)
+        response.result = orjson.dumps(res)
         return response
 
-    async def transfer_to_master(self, request: mr.MarketRequest) -> mr.SimpleResponse:
-        response = mr.SimpleResponse()
+    async def transfer_to_master(self, request: mr.MarketRequest) -> SimpleResponse:
+        response = SimpleResponse()
         response.success = False
 
         res, _, _ = await self.send_request(
@@ -745,13 +770,13 @@ class Martin(mr.MartinBase):
 
         if res and res.get("txnId"):
             response.success = True
-        response.result = json.dumps(res)
+        response.result = orjson.dumps(res)
         return response
 
-    async def start_stream(self, request: mr.StartStreamRequest) -> mr.SimpleResponse:
+    async def start_stream(self, request: mr.StartStreamRequest) -> SimpleResponse:
         open_client = OpenClient.get_client(request.client_id)
         client = open_client.client
-        response = mr.SimpleResponse()
+        response = SimpleResponse()
         _market_stream_count = 0
         while _market_stream_count < request.market_stream_count:
             await asyncio.sleep(HEARTBEAT)
@@ -764,8 +789,8 @@ class Martin(mr.MartinBase):
         response.success = True
         return response
 
-    async def stop_stream(self, request: mr.MarketRequest) -> mr.SimpleResponse:
-        response = mr.SimpleResponse()
+    async def stop_stream(self, request: mr.MarketRequest) -> SimpleResponse:
+        response = SimpleResponse()
         if open_client := OpenClient.get_client(request.client_id):
             client = open_client.client
             logger.info(f"StopStream request for {request.symbol} on {client.exchange}")
@@ -775,17 +800,17 @@ class Martin(mr.MartinBase):
             response.success = False
         return response
 
-    async def check_stream(self, request: mr.MarketRequest) -> mr.SimpleResponse:
+    async def check_stream(self, request: mr.MarketRequest) -> SimpleResponse:
         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)
+        response = 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:
+    async def client_restart(self, request: mr.MarketRequest) -> SimpleResponse:
         await self.stop_stream(request)
         if client := OpenClient.get_client(request.client_id).client:
             if user_session := client.user_session:
@@ -793,7 +818,7 @@ class Martin(mr.MartinBase):
             if session := client.http:
                 await session.close_session()
         OpenClient.remove_client(request.client_id)
-        return mr.SimpleResponse(success=True)
+        return SimpleResponse(success=True)
 
 
 async def stop_stream_ex(client, trade_id):

{exchanges_wrapper-2.1.52 → exchanges_wrapper-2.2.4}/exchanges_wrapper/http_client.py

@@ -1,7 +1,6 @@
 import asyncio
-import ujson as json
+import orjson
 from urllib.parse import urlencode, urlparse
-
 import aiohttp
 import logging
 import time
@@ -189,7 +188,7 @@ class HttpClient:
     async def _bitfinex_request(self, path, method, signed, send_api_key, endpoint, timeout, **kwargs):
         _endpoint = endpoint or self.endpoint
         bfx_post = (method == 'POST' and kwargs) or "params" in kwargs
-        _params = json.dumps(kwargs) if bfx_post else {}
+        _params = orjson.dumps(kwargs).decode() if bfx_post else {}
         url = f'{_endpoint}/{path}'
         query_kwargs = {"headers": {"Accept": AJ}}
         if kwargs and not bfx_post:
@@ -236,7 +235,7 @@ class HttpClient:
                 signature_payload = f"{ts}{self.api_key}{query_string}"
             else:
                 url += path
-                data = json.dumps(kwargs)
+                data = orjson.dumps(kwargs).decode()
                 signature_payload = f"{ts}{self.api_key}{data}"
 
             signature = generate_signature(self.exchange, self.api_secret, signature_payload)
@@ -288,7 +287,7 @@ class HttpClient:
         if signed:
             ts = f"{datetime.now(timezone.utc).replace(tzinfo=None).isoformat('T', 'milliseconds')}Z"
             if method == 'POST' and kwargs:
-                data = json.dumps(kwargs.get('data') if 'data' in kwargs else kwargs)
+                data = orjson.dumps(kwargs.get('data') if 'data' in kwargs else kwargs).decode()
                 signature_payload = f"{ts}{method}{path}{data}"
             else:
                 signature_payload = f"{ts}{method}{path}"

{exchanges_wrapper-2.1.52 → exchanges_wrapper-2.2.4}/exchanges_wrapper/martin/__init__.py

@@ -16,7 +16,6 @@ import betterproto
 import grpclib
 from betterproto.grpc.grpclib_server import ServiceBase
 
-
 if TYPE_CHECKING:
     import grpclib.server
     from betterproto.grpc.grpclib_client import MetadataLike
@@ -24,13 +23,13 @@ if TYPE_CHECKING:
 
 
 @dataclass(eq=False, repr=False)
-class JsonResponse(betterproto.Message):
-    items: List[str] = betterproto.string_field(1)
+class BytesResponse(betterproto.Message):
+    items: List[bytes] = betterproto.bytes_field(1)
 
 
 @dataclass(eq=False, repr=False)
 class StreamResponse(betterproto.Message):
-    event: str = betterproto.string_field(1)
+    event: bytes = betterproto.bytes_field(1)
 
 
 @dataclass(eq=False, repr=False)
@@ -146,7 +145,7 @@ class OnFundsUpdateRequest(betterproto.Message):
 @dataclass(eq=False, repr=False)
 class SimpleResponse(betterproto.Message):
     success: bool = betterproto.bool_field(1)
-    result: str = betterproto.string_field(2)
+    result: bytes = betterproto.bytes_field(2)
 
 
 @dataclass(eq=False, repr=False)
@@ -169,7 +168,7 @@ class AccountTradeListRequest(betterproto.Message):
 class OnKlinesUpdateResponse(betterproto.Message):
     symbol: str = betterproto.string_field(1)
     interval: str = betterproto.string_field(2)
-    candle: str = betterproto.string_field(3)
+    candle: bytes = betterproto.bytes_field(3)
 
 
 @dataclass(eq=False, repr=False)
@@ -179,6 +178,7 @@ class FetchKlinesRequest(betterproto.Message):
     symbol: str = betterproto.string_field(3)
     interval: str = betterproto.string_field(4)
     limit: int = betterproto.uint32_field(5)
+    intervals: bytes = betterproto.bytes_field(6)
 
 
 @dataclass(eq=False, repr=False)
@@ -215,8 +215,8 @@ class FetchSymbolPriceTickerResponse(betterproto.Message):
 @dataclass(eq=False, repr=False)
 class FetchOrderBookResponse(betterproto.Message):
     last_update_id: int = betterproto.uint64_field(1)
-    bids: List[str] = betterproto.string_field(2)
-    asks: List[str] = betterproto.string_field(3)
+    bids: List[bytes] = betterproto.bytes_field(2)
+    asks: List[bytes] = betterproto.bytes_field(3)
 
 
 @dataclass(eq=False, repr=False)
@@ -397,7 +397,7 @@ class FetchOrderResponse(betterproto.Message):
 @dataclass(eq=False, repr=False)
 class FetchOpenOrdersResponse(betterproto.Message):
     rate_limiter: int = betterproto.int32_field(1)
-    orders: List[str] = betterproto.string_field(2)
+    orders: List[bytes] = betterproto.bytes_field(2)
 
 
 @dataclass(eq=False, repr=False)
@@ -526,11 +526,11 @@ class MartinStub(betterproto.ServiceStub):
         timeout: Optional[float] = None,
         deadline: Optional["Deadline"] = None,
         metadata: Optional["MetadataLike"] = None
-    ) -> "JsonResponse":
+    ) -> "BytesResponse":
         return await self._unary_unary(
             "/martin.Martin/FetchAccountInformation",
             open_client_connection_id,
-            JsonResponse,
+            BytesResponse,
             timeout=timeout,
             deadline=deadline,
             metadata=metadata,
@@ -543,11 +543,11 @@ class MartinStub(betterproto.ServiceStub):
         timeout: Optional[float] = None,
         deadline: Optional["Deadline"] = None,
         metadata: Optional["MetadataLike"] = None
-    ) -> "JsonResponse":
+    ) -> "BytesResponse":
         return await self._unary_unary(
             "/martin.Martin/FetchAccountTradeList",
             account_trade_list_request,
-            JsonResponse,
+            BytesResponse,
             timeout=timeout,
             deadline=deadline,
             metadata=metadata,
@@ -577,11 +577,11 @@ class MartinStub(betterproto.ServiceStub):
         timeout: Optional[float] = None,
         deadline: Optional["Deadline"] = None,
         metadata: Optional["MetadataLike"] = None
-    ) -> "JsonResponse":
+    ) -> "BytesResponse":
         return await self._unary_unary(
             "/martin.Martin/FetchFundingWallet",
             fetch_funding_wallet_request,
-            JsonResponse,
+            BytesResponse,
             timeout=timeout,
             deadline=deadline,
             metadata=metadata,
@@ -594,11 +594,11 @@ class MartinStub(betterproto.ServiceStub):
         timeout: Optional[float] = None,
         deadline: Optional["Deadline"] = None,
         metadata: Optional["MetadataLike"] = None
-    ) -> "JsonResponse":
+    ) -> "BytesResponse":
         return await self._unary_unary(
             "/martin.Martin/FetchKlines",
             fetch_klines_request,
-            JsonResponse,
+            BytesResponse,
             timeout=timeout,
             deadline=deadline,
             metadata=metadata,
@@ -973,12 +973,12 @@ class MartinBase(ServiceBase):
 
     async def fetch_account_information(
         self, open_client_connection_id: "OpenClientConnectionId"
-    ) -> "JsonResponse":
+    ) -> "BytesResponse":
         raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
 
     async def fetch_account_trade_list(
         self, account_trade_list_request: "AccountTradeListRequest"
-    ) -> "JsonResponse":
+    ) -> "BytesResponse":
         raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
 
     async def fetch_exchange_info_symbol(
@@ -988,12 +988,12 @@ class MartinBase(ServiceBase):
 
     async def fetch_funding_wallet(
         self, fetch_funding_wallet_request: "FetchFundingWalletRequest"
-    ) -> "JsonResponse":
+    ) -> "BytesResponse":
         raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
 
     async def fetch_klines(
         self, fetch_klines_request: "FetchKlinesRequest"
-    ) -> "JsonResponse":
+    ) -> "BytesResponse":
         raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
 
     async def fetch_open_orders(
@@ -1128,14 +1128,14 @@ class MartinBase(ServiceBase):
         await stream.send_message(response)
 
     async def __rpc_fetch_account_information(
-        self, stream: "grpclib.server.Stream[OpenClientConnectionId, JsonResponse]"
+        self, stream: "grpclib.server.Stream[OpenClientConnectionId, BytesResponse]"
     ) -> None:
         request = await stream.recv_message()
         response = await self.fetch_account_information(request)
         await stream.send_message(response)
 
     async def __rpc_fetch_account_trade_list(
-        self, stream: "grpclib.server.Stream[AccountTradeListRequest, JsonResponse]"
+        self, stream: "grpclib.server.Stream[AccountTradeListRequest, BytesResponse]"
     ) -> None:
         request = await stream.recv_message()
         response = await self.fetch_account_trade_list(request)
@@ -1150,14 +1150,14 @@ class MartinBase(ServiceBase):
         await stream.send_message(response)
 
     async def __rpc_fetch_funding_wallet(
-        self, stream: "grpclib.server.Stream[FetchFundingWalletRequest, JsonResponse]"
+        self, stream: "grpclib.server.Stream[FetchFundingWalletRequest, BytesResponse]"
     ) -> None:
         request = await stream.recv_message()
         response = await self.fetch_funding_wallet(request)
         await stream.send_message(response)
 
     async def __rpc_fetch_klines(
-        self, stream: "grpclib.server.Stream[FetchKlinesRequest, JsonResponse]"
+        self, stream: "grpclib.server.Stream[FetchKlinesRequest, BytesResponse]"
     ) -> None:
         request = await stream.recv_message()
         response = await self.fetch_klines(request)
@@ -1356,13 +1356,13 @@ class MartinBase(ServiceBase):
                 self.__rpc_fetch_account_information,
                 grpclib.const.Cardinality.UNARY_UNARY,
                 OpenClientConnectionId,
-                JsonResponse,
+                BytesResponse,
             ),
             "/martin.Martin/FetchAccountTradeList": grpclib.const.Handler(
                 self.__rpc_fetch_account_trade_list,
                 grpclib.const.Cardinality.UNARY_UNARY,
                 AccountTradeListRequest,
-                JsonResponse,
+                BytesResponse,
             ),
             "/martin.Martin/FetchExchangeInfoSymbol": grpclib.const.Handler(
                 self.__rpc_fetch_exchange_info_symbol,
@@ -1374,13 +1374,13 @@ class MartinBase(ServiceBase):
                 self.__rpc_fetch_funding_wallet,
                 grpclib.const.Cardinality.UNARY_UNARY,
                 FetchFundingWalletRequest,
-                JsonResponse,
+                BytesResponse,
             ),
             "/martin.Martin/FetchKlines": grpclib.const.Handler(
                 self.__rpc_fetch_klines,
                 grpclib.const.Cardinality.UNARY_UNARY,
                 FetchKlinesRequest,
-                JsonResponse,
+                BytesResponse,
             ),
             "/martin.Martin/FetchOpenOrders": grpclib.const.Handler(
                 self.__rpc_fetch_open_orders,

{exchanges_wrapper-2.1.52 → exchanges_wrapper-2.2.4}/exchanges_wrapper/parsers/huobi.py

@@ -8,7 +8,7 @@ import logging
 logger = logging.getLogger(__name__)
 
 
-def on_balance_update(res: {}) -> {}:
+def on_balance_update(res: dict) -> dict:
     return {
         'e': 'balanceUpdate',
         'E': res.get('transactTime'),
@@ -18,11 +18,11 @@ def on_balance_update(res: {}) -> {}:
     }
 
 
-def fetch_server_time(res: {}) -> {}:
+def fetch_server_time(res: dict) -> dict:
     return {'serverTime': res}
 
 
-def exchange_info(server_time: int, _symbol_params) -> {}:
+def exchange_info(server_time: int, _symbol_params) -> dict:
     _tick_size = str(10**(-_symbol_params.get('pp')))
     _price_filter = {
         "filterType": "PRICE_FILTER",
@@ -87,7 +87,7 @@ def orders(res: list, response_type=None) -> list:
     return binance_orders
 
 
-def order(res: {}, response_type=None) -> {}:
+def order(res: dict, response_type=None) -> dict:
     symbol = res.get('symbol').upper()
     order_id = res.get('id')
     order_list_id = -1
@@ -171,7 +171,7 @@ def order(res: {}, response_type=None) -> {}:
         }
 
 
-def order_cancelled(symbol, order_id=None, origin_client_order_id=None,) -> {}:
+def order_cancelled(symbol, order_id=None, origin_client_order_id=None,) -> dict:
     return {
         "symbol": symbol,
         "origClientOrderId": origin_client_order_id,
@@ -190,7 +190,7 @@ def order_cancelled(symbol, order_id=None, origin_client_order_id=None,) -> {}:
     }
 
 
-def account_balances(res: {}) -> {}:
+def account_balances(res: dict) -> dict:
     """
     This function parses the Huobi API response for account information and
     returns a dictionary with relevant details.
@@ -205,7 +205,7 @@ def account_balances(res: {}) -> {}:
     # Filter out balances that have zero value
     res[:] = [i for i in res if i.get('balance') != '0']
 
-    assets = {}
+    assets = dict
     for balance in res:
         asset = balance['currency']
         assets.setdefault(asset, {
@@ -230,12 +230,12 @@ def account_balances(res: {}) -> {}:
     return {"balances": balances}
 
 
-def order_book(res: {}) -> {}:
+def order_book(res: dict) -> dict:
     res["lastUpdateId"] = res.pop("ts")
     return res
 
 
-def order_book_ws(res: {}, symbol: str) -> {}:
+def order_book_ws(res: dict, symbol: str) -> dict:
     return {
         'stream': f"{symbol}@depth5",
         'data': {'lastUpdateId': res['ts'],
@@ -245,14 +245,14 @@ def order_book_ws(res: {}, symbol: str) -> {}:
     }
 
 
-def fetch_symbol_price_ticker(res: {}, symbol) -> {}:
+def fetch_symbol_price_ticker(res: dict, symbol) -> dict:
     return {
         "symbol": symbol,
         "price": str(res.get('data')[0].get('price'))
     }
 
 
-def ticker_price_change_statistics(res: {}, symbol) -> {}:
+def ticker_price_change_statistics(res: dict, symbol) -> dict:
     return {
         "symbol": symbol,
         "priceChange": str(res.get('close') - res.get('open')),
@@ -280,8 +280,8 @@ def ticker_price_change_statistics(res: {}, symbol) -> {}:
     }
 
 
-def ticker(res: {}, symbol: str = None) -> {}:
-    tick = res.get('tick')
+def ticker(res: dict, symbol: str = None) -> dict:
+    tick: dict = res.get('tick')
     return {
         'stream': f"{symbol}@miniTicker",
         'data': {
@@ -350,9 +350,9 @@ def klines(res: list, _interval: str) -> list:
     return binance_klines
 
 
-def candle(res: dict, symbol: str = None, ch_type: str = None) -> {}:
-    tick = res.get('tick')
-    start_time = tick.get('id')
+def candle(res: dict, symbol = '', ch_type = '') -> dict:
+    tick: dict = res.get('tick')
+    start_time = tick.get('id') * 1000
     _interval = ch_type.split('_')[1]
     end_time = start_time + interval2value(interval(_interval)) * 1000 - 1
     return {
@@ -384,7 +384,7 @@ def candle(res: dict, symbol: str = None, ch_type: str = None) -> {}:
     }
 
 
-def on_funds_update(data: {}) -> {}:
+def on_funds_update(data: dict) -> dict:
     event_time = int(time.time() * 1000)
     binance_funds = {
         'e': 'outboundAccountPosition',
@@ -404,7 +404,7 @@ def on_funds_update(data: {}) -> {}:
     return binance_funds
 
 
-def on_order_update(_order: {}) -> {}:
+def on_order_update(_order: dict) -> dict:
     event = _order['lastEvent']
     order_quantity = event.get('orderSize', event.get('orderValue'))
     order_price = event.get('orderPrice', event.get('tradePrice'))

{exchanges_wrapper-2.1.52 → exchanges_wrapper-2.2.4}/exchanges_wrapper/proto/martin.proto

@@ -1,4 +1,5 @@
 /*
+__version__ = "2.2.1"
 Protocol buffer definition for exchanges-wrapper exch_srv.py
 https://grpc.io/docs/languages/python/quickstart/
 For compile use next commands
@@ -16,11 +17,11 @@ service Martin {
   rpc CancelOrder (CancelOrderRequest) returns (CancelOrderResponse) {}
   rpc CheckStream (MarketRequest) returns (SimpleResponse) {}
   rpc CreateLimitOrder (CreateLimitOrderRequest) returns (CreateLimitOrderResponse) {}
-  rpc FetchAccountInformation (OpenClientConnectionId) returns (JSONResponse) {}
-  rpc FetchAccountTradeList (AccountTradeListRequest) returns (JSONResponse) {}
+  rpc FetchAccountInformation (OpenClientConnectionId) returns (BytesResponse) {}
+  rpc FetchAccountTradeList (AccountTradeListRequest) returns (BytesResponse) {}
   rpc FetchExchangeInfoSymbol (MarketRequest) returns (FetchExchangeInfoSymbolResponse) {}
-  rpc FetchFundingWallet(FetchFundingWalletRequest) returns (JSONResponse) {}
-  rpc FetchKlines (FetchKlinesRequest) returns (JSONResponse) {}
+  rpc FetchFundingWallet(FetchFundingWalletRequest) returns (BytesResponse) {}
+  rpc FetchKlines (FetchKlinesRequest) returns (BytesResponse) {}
   rpc FetchOpenOrders (MarketRequest) returns (FetchOpenOrdersResponse) {}
   rpc FetchOrder (FetchOrderRequest) returns (FetchOrderResponse) {}
   rpc FetchOrderBook (MarketRequest) returns (FetchOrderBookResponse) {}
@@ -43,12 +44,12 @@ service Martin {
   rpc ClientRestart (MarketRequest) returns (SimpleResponse) {}
 }
 
-message JSONResponse {
-  repeated string items = 1;
+message BytesResponse {
+  repeated bytes items = 1;
 }
 
 message StreamResponse {
-  string event = 1;
+  bytes event = 1;
 }
 
 message FetchFundingWalletRequest{
@@ -157,7 +158,7 @@ message OnFundsUpdateRequest {
 
 message SimpleResponse {
   bool success = 1;
-  string result = 2;
+  bytes result = 2;
 }
 
 message OnTickerUpdateResponse {
@@ -177,7 +178,7 @@ message AccountTradeListRequest {
 message OnKlinesUpdateResponse {
   string symbol = 1;
   string interval =2;
-  string candle = 3;
+  bytes candle = 3;
 }
 
 message FetchKlinesRequest {
@@ -186,6 +187,7 @@ message FetchKlinesRequest {
   string symbol = 3;
   string interval = 4;
   uint32 limit = 5;
+  bytes intervals = 6;
 }
 
 message FetchTickerPriceChangeStatisticsResponse {
@@ -219,8 +221,8 @@ message FetchSymbolPriceTickerResponse {
 
 message FetchOrderBookResponse {
   uint64 lastUpdateId = 1;
-  repeated string bids = 2;
-  repeated string asks = 3;
+  repeated bytes bids = 2;
+  repeated bytes asks = 3;
 }
 
 message FetchExchangeInfoSymbolResponse {
@@ -362,7 +364,7 @@ message FetchOrderResponse {
 
 message FetchOpenOrdersResponse {
   int32 rate_limiter = 1;
-  repeated string orders = 2;
+  repeated bytes orders = 2;
 }
 
 message MarketRequest {

{exchanges_wrapper-2.1.52 → exchanges_wrapper-2.2.4}/exchanges_wrapper/web_sockets.py

@@ -2,9 +2,7 @@ import sys
 import asyncio
 import gc
 import logging
-
-# noinspection PyPackageRequirements
-import ujson as json
+import orjson
 from pathlib import Path
 import time
 from decimal import Decimal
@@ -114,7 +112,7 @@ class EventsDataStream:
         pass  # meant to be overridden in a subclass
 
     async def _handle_messages(self, msg, symbol=None, ch_type=str()):
-        msg_data = json.loads(msg if isinstance(msg, str) else gzip.decompress(msg))
+        msg_data = orjson.loads(msg if isinstance(msg, str) else gzip.decompress(msg))
         if self.exchange == 'binance':
             if "stream" in msg_data:
                 await self._handle_event(msg_data)
@@ -217,7 +215,7 @@ class EventsDataStream:
         elif self.exchange == 'huobi':
             if ping := msg_data.get('ping'):
                 self.ping = 0
-                await self.websocket.send(json.dumps({"pong": ping}))
+                await self.websocket.send(orjson.dumps({"pong": ping}), text = True)
                 await asyncio.sleep(0)
             elif msg_data.get('action') == 'ping':
                 self.ping = 0
@@ -227,7 +225,7 @@ class EventsDataStream:
                           "ts": msg_data.get('data').get('ts')
                     }
                 }
-                await self.websocket.send(json.dumps(pong))
+                await self.websocket.send(orjson.dumps(pong), text = True)
                 await asyncio.sleep(0)
             elif msg_data.get('tick') or msg_data.get('data'):
                 if ch_type == 'ticker':
@@ -252,7 +250,7 @@ class EventsDataStream:
 
     async def ws_listener(self, request=None, symbol=None, ch_type=str()):
         if request:
-            await self.websocket.send(json.dumps(request))
+            await self.websocket.send(orjson.dumps(request), text = True)
             await asyncio.sleep(0)
         async for msg_data in self.websocket:
             await self._handle_messages(msg_data, symbol, ch_type)
@@ -261,7 +259,7 @@ class EventsDataStream:
         while True:
             await asyncio.sleep(interval)
             try:
-                await self.websocket.send(json.dumps({"req_id": req_id, "op": "ping"}))
+                await self.websocket.send(orjson.dumps({"req_id": req_id, "op": "ping"}), text = True)
             except (ConnectionClosed, asyncio.exceptions.TimeoutError, AttributeError):
                 break
 
@@ -418,9 +416,10 @@ class HbpPrivateEventsDataStream(EventsDataStream):
 
     async def start_wss(self):
         await self.websocket.send(
-            json.dumps(
+            orjson.dumps(
                 compose_htx_ws_auth(self.endpoint, self.exchange, self.client.api_key, self.client.api_secret)
-            )
+            ),
+            text = True
         )
         await asyncio.sleep(0)
         await self._handle_messages(await self.websocket.recv(), symbol=self.symbol)
@@ -429,7 +428,7 @@ class HbpPrivateEventsDataStream(EventsDataStream):
             "action": "sub",
             "ch": "accounts.update#2"
         }
-        await self.websocket.send(json.dumps(request))
+        await self.websocket.send(orjson.dumps(request), text = True)
         await asyncio.sleep(0)
         await self._handle_messages(await self.websocket.recv(), symbol=self.symbol)
         #
@@ -437,7 +436,7 @@ class HbpPrivateEventsDataStream(EventsDataStream):
             "action": "sub",
             "ch": f"orders#{self.symbol.lower()}"
         }
-        await self.websocket.send(json.dumps(request))
+        await self.websocket.send(orjson.dumps(request), text = True)
         await asyncio.sleep(0)
         await self._handle_messages(await self.websocket.recv(), symbol=self.symbol)
         #
@@ -546,7 +545,7 @@ class OkxPrivateEventsDataStream(EventsDataStream):
                              "sign": signature}
                             ]
                    }
-        await self.websocket.send(json.dumps(request))
+        await self.websocket.send(orjson.dumps(request), text = True)
         await asyncio.sleep(0)
         await self._handle_messages(await self.websocket.recv())
         # Channel subscription
@@ -598,7 +597,7 @@ class BBTPrivateEventsDataStream(EventsDataStream):
             "op": 'auth',
             "args": [self.client.api_key, ts, signature]
         }
-        await self.websocket.send(json.dumps(request))
+        await self.websocket.send(orjson.dumps(request), text = True)
         await asyncio.sleep(0)
         await self._handle_messages(await self.websocket.recv())
         # Channel subscription
@@ -633,9 +632,10 @@ class UserEventsDataStream(EventsDataStream):
 
     async def start_wss(self):
         await self.websocket.send(
-            json.dumps(
+            orjson.dumps(
                 compose_binance_ws_auth(self.trade_id, self.client.api_key, self.client.api_secret)
-            )
+            ),
+            text = True
         )
         await asyncio.sleep(0)
         await self._handle_messages(await self.websocket.recv())

{exchanges_wrapper-2.1.52 → exchanges_wrapper-2.2.4}/pyproject.toml

@@ -20,9 +20,8 @@ dynamic = ["version", "description"]
 requires-python = ">=3.12"
 
 dependencies = [
-    "crypto-ws-api==2.1.12",
+    "crypto-ws-api==2.1.15",
     "pyotp==2.10.0",
-    "simplejson==4.1.1",
     "aiohttp==3.14.3",
     "expiringdict==1.2.2",
     "betterproto==2.0.0b7",