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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: exchanges-wrapper
-Version: 2.2.2
+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

{exchanges_wrapper-2.2.2 → 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.2.2"
+__version__ = "2.2.4"
 
 from pathlib import Path
 import shutil

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

@@ -478,24 +478,26 @@ 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 = orjson.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()
 
@@ -544,13 +546,13 @@ 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()
 
@@ -581,10 +583,21 @@ 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.extend(orjson.dumps(v) for v in _event.bids)
-                    response.asks.extend(orjson.dumps(v) for v in _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()
 
@@ -604,6 +617,7 @@ class Martin(mr.MartinBase):
                 logger.info(f"OnFundsUpdate: Stop user stream for {open_client.name}: {request.symbol}")
                 return
             else:
+                response.event = b""
                 response.event = orjson.dumps(_event.balances)
                 yield response
                 _queue.task_done()
@@ -641,13 +655,18 @@ 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 = b""
                     response.event = orjson.dumps(balance)
                     yield response
 
@@ -671,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 = orjson.dumps(event)
+                response.result = orjson.dumps(event_dict)
+
                 yield response
                 _queue.task_done()
 

{exchanges_wrapper-2.2.2 → 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'))