exchanges-wrapper 1.4.2__tar.gz → 1.4.4__tar.gz

{exchanges_wrapper-1.4.2 → exchanges_wrapper-1.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: exchanges-wrapper
-Version: 1.4.2
+Version: 1.4.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.8

{exchanges_wrapper-1.4.2 → exchanges_wrapper-1.4.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__ = "1.4.2"
+__version__ = "1.4.4"
 
 from pathlib import Path
 import shutil

{exchanges_wrapper-1.4.2 → exchanges_wrapper-1.4.4}/exchanges_wrapper/exch_srv.py

@@ -268,7 +268,7 @@ class Martin(api_pb2_grpc.MartinServicer):
             for order in res:
                 order_id = order['orderId']
                 active_orders.append(order_id)
-                new_order = json_format.ParseDict(order, response_order)
+                new_order = json_format.ParseDict(order, response_order, ignore_unknown_fields=True)
                 # logger.debug(f"FetchOpenOrders.new_order: {new_order}")
                 response.items.append(new_order)
                 if client.exchange == 'bitfinex':
@@ -316,20 +316,23 @@ class Martin(api_pb2_grpc.MartinServicer):
                                 f"{event.order_status}")
                     await _queue.put(weakref.ref(event)())
                 elif res.get('status') == 'PARTIALLY_FILLED':
-                    try:
-                        trades = await client.fetch_order_trade_list(request.trade_id, request.symbol, request.order_id)
-                    except asyncio.CancelledError:
-                        pass  # Task cancellation should not be logged as an error
-                    except Exception as _ex:
-                        logger.error(f"Fetch order trades for {open_client.name}: {request.symbol} exception: {_ex}")
-                    else:
-                        logger.debug(f"FetchOrder.trades: {trades}")
-                        for trade in trades:
-                            event = OrderTradesEvent(trade)
-                            await _queue.put(weakref.ref(event)())
-            json_format.ParseDict(res, response)
+                    await self.create_trade_stream_event(_queue, client, open_client, request)
+            json_format.ParseDict(res, response, ignore_unknown_fields=True)
         return response
 
+    async def create_trade_stream_event(self, _queue, client, open_client, request):
+        try:
+            trades = await client.fetch_order_trade_list(request.trade_id, request.symbol, request.order_id)
+        except asyncio.CancelledError:
+            pass  # Task cancellation should not be logged as an error
+        except Exception as _ex:
+            logger.error(f"Fetch order trades for {open_client.name}: {request.symbol} exception: {_ex}")
+        else:
+            logger.debug(f"FetchOrder.trades: {trades}")
+            for trade in trades:
+                event = OrderTradesEvent(trade)
+                await _queue.put(weakref.ref(event)())
+
     async def CancelAllOrders(self, request: api_pb2.MarketRequest,
                               _context: grpc.aio.ServicerContext) -> api_pb2.SimpleResponse():
         open_client = OpenClient.get_client(request.client_id)
@@ -360,51 +363,71 @@ class Martin(api_pb2_grpc.MartinServicer):
         else:
             raise UserWarning(f"Symbol {request.symbol} not exist")
         await self.rate_limit_control(open_client)
-        # logger.info(f"exchange_info_symbol: {exchange_info_symbol}")
+        # logger.debug(f"exchange_info_symbol: {exchange_info_symbol}")
         open_client.ts_rlc = time.time()
         filters_res = exchange_info_symbol.pop('filters', [])
-        json_format.ParseDict(exchange_info_symbol, response)
+        json_format.ParseDict(exchange_info_symbol, response, ignore_unknown_fields=True)
         # logger.info(f"filters: {filters_res}")
         filters = response.filters
         for _filter in filters_res:
             filter_type = _filter.get('filterType')
             if filter_type == 'PRICE_FILTER':
                 new_filter_template = api_pb2.FetchExchangeInfoSymbolResponse.Filters.PriceFilter()
-                filters.price_filter.CopyFrom(json_format.ParseDict(_filter, new_filter_template))
+                filters.price_filter.CopyFrom(
+                    json_format.ParseDict(_filter, new_filter_template, ignore_unknown_fields=True)
+                )
             elif 'PERCENT_PRICE' in filter_type:
                 if filter_type == 'PERCENT_PRICE_BY_SIDE':
-                    _filter['multiplierUp'] = _filter['bidMultiplierUp']
+                    _filter['multiplierUp'] = _filter['askMultiplierUp']
                     _filter['multiplierDown'] = _filter['bidMultiplierDown']
                     del _filter['bidMultiplierUp']
                     del _filter['bidMultiplierDown']
                     del _filter['askMultiplierUp']
                     del _filter['askMultiplierDown']
                 new_filter_template = api_pb2.FetchExchangeInfoSymbolResponse.Filters.PercentPrice()
-                filters.percent_price.CopyFrom(json_format.ParseDict(_filter, new_filter_template))
+                filters.percent_price.CopyFrom(
+                    json_format.ParseDict(_filter, new_filter_template, ignore_unknown_fields=True)
+                )
             elif filter_type == 'LOT_SIZE':
                 new_filter_template = api_pb2.FetchExchangeInfoSymbolResponse.Filters.LotSize()
-                filters.lot_size.CopyFrom(json_format.ParseDict(_filter, new_filter_template))
+                filters.lot_size.CopyFrom(
+                    json_format.ParseDict(_filter, new_filter_template, ignore_unknown_fields=True)
+                )
             elif filter_type == 'MIN_NOTIONAL':
                 new_filter_template = api_pb2.FetchExchangeInfoSymbolResponse.Filters.MinNotional()
-                filters.min_notional.CopyFrom(json_format.ParseDict(_filter, new_filter_template))
+                filters.min_notional.CopyFrom(
+                    json_format.ParseDict(_filter, new_filter_template, ignore_unknown_fields=True)
+                )
             elif filter_type == 'NOTIONAL':
                 new_filter_template = api_pb2.FetchExchangeInfoSymbolResponse.Filters.Notional()
-                filters.notional.CopyFrom(json_format.ParseDict(_filter, new_filter_template))
+                filters.notional.CopyFrom(
+                    json_format.ParseDict(_filter, new_filter_template, ignore_unknown_fields=True)
+                )
             elif filter_type == 'ICEBERG_PARTS':
                 new_filter_template = api_pb2.FetchExchangeInfoSymbolResponse.Filters.IcebergParts()
-                filters.iceberg_parts.CopyFrom(json_format.ParseDict(_filter, new_filter_template))
+                filters.iceberg_parts.CopyFrom(
+                    json_format.ParseDict(_filter, new_filter_template, ignore_unknown_fields=True)
+                )
             elif filter_type == 'MARKET_LOT_SIZE':
                 new_filter_template = api_pb2.FetchExchangeInfoSymbolResponse.Filters.MarketLotSize()
-                filters.market_lot_size.CopyFrom(json_format.ParseDict(_filter, new_filter_template))
+                filters.market_lot_size.CopyFrom(
+                    json_format.ParseDict(_filter, new_filter_template, ignore_unknown_fields=True)
+                )
             elif filter_type == 'MAX_NUM_ORDERS':
                 new_filter_template = api_pb2.FetchExchangeInfoSymbolResponse.Filters.MaxNumOrders()
-                filters.max_num_orders.CopyFrom(json_format.ParseDict(_filter, new_filter_template))
+                filters.max_num_orders.CopyFrom(
+                    json_format.ParseDict(_filter, new_filter_template, ignore_unknown_fields=True)
+                )
             elif filter_type == 'MAX_NUM_ICEBERG_ORDERS':
                 new_filter_template = api_pb2.FetchExchangeInfoSymbolResponse.Filters.MaxNumIcebergOrders()
-                filters.max_num_iceberg_orders.CopyFrom(json_format.ParseDict(_filter, new_filter_template))
+                filters.max_num_iceberg_orders.CopyFrom(
+                    json_format.ParseDict(_filter, new_filter_template, ignore_unknown_fields=True)
+                )
             elif filter_type == 'MAX_POSITION':
                 new_filter_template = api_pb2.FetchExchangeInfoSymbolResponse.Filters.MaxPosition()
-                filters.max_position.CopyFrom(json_format.ParseDict(_filter, new_filter_template))
+                filters.max_position.CopyFrom(
+                    json_format.ParseDict(_filter, new_filter_template, ignore_unknown_fields=True)
+                )
         return response
 
     async def FetchAccountInformation(self, request: api_pb2.OpenClientConnectionId,
@@ -428,7 +451,7 @@ class Martin(api_pb2_grpc.MartinServicer):
                 balances.append({'asset': i.get('asset'), 'free': i.get('free'), 'locked': i.get('locked')})
         # logger.info(f"account_information.balances: {balances}")
         for balance in balances:
-            new_balance = json_format.ParseDict(balance, response_balance)
+            new_balance = json_format.ParseDict(balance, response_balance, ignore_unknown_fields=True)
             response.balances.extend([new_balance])
         return response
 
@@ -451,7 +474,7 @@ class Martin(api_pb2_grpc.MartinServicer):
         open_client.ts_rlc = time.time()
         logger.debug(f"funding_wallet: {res}")
         for balance in res:
-            new_balance = json_format.ParseDict(balance, response_balance)
+            new_balance = json_format.ParseDict(balance, response_balance, ignore_unknown_fields=True)
             response.balances.extend([new_balance])
         return response
 
@@ -482,7 +505,7 @@ class Martin(api_pb2_grpc.MartinServicer):
         await self.rate_limit_control(open_client)
         res = await client.fetch_symbol_price_ticker(symbol=request.symbol)
         open_client.ts_rlc = time.time()
-        json_format.ParseDict(res, response)
+        json_format.ParseDict(res, response, ignore_unknown_fields=True)
         return response
 
     async def FetchTickerPriceChangeStatistics(
@@ -494,7 +517,7 @@ class Martin(api_pb2_grpc.MartinServicer):
         await self.rate_limit_control(open_client)
         res = await client.fetch_ticker_price_change_statistics(symbol=request.symbol)
         open_client.ts_rlc = time.time()
-        json_format.ParseDict(res, response)
+        json_format.ParseDict(res, response, ignore_unknown_fields=True)
         return response
 
     async def FetchKlines(self, request: api_pb2.FetchKlinesRequest,
@@ -597,7 +620,7 @@ class Martin(api_pb2_grpc.MartinServicer):
             # logger.info(f"FetchAccountTradeList: {res}")
             open_client.ts_rlc = time.time()
             for trade in res:
-                trade_order = json_format.ParseDict(trade, response_trade)
+                trade_order = json_format.ParseDict(trade, response_trade, ignore_unknown_fields=True)
                 response.items.append(trade_order)
         return response
 
@@ -632,7 +655,7 @@ class Martin(api_pb2_grpc.MartinServicer):
                               'close_price': _event.close_price,
                               'event_time': _event.event_time}
                 # logger.info(f"OnTickerUpdate.event: {_event.symbol}, ticker_24h: {ticker_24h}")
-                json_format.ParseDict(ticker_24h, response)
+                json_format.ParseDict(ticker_24h, response, ignore_unknown_fields=True)
                 yield response
                 _queue.task_done()
 
@@ -813,7 +836,7 @@ class Martin(api_pb2_grpc.MartinServicer):
                                                origin_client_order_id=request.new_client_order_id,
                                                receive_window=None,
                                                response_type=False)
-            json_format.ParseDict(res, response)
+            json_format.ParseDict(res, response, ignore_unknown_fields=True)
             logger.debug(f"CreateLimitOrder: for {open_client.name}:{request.symbol}: created: {res.get('orderId')}")
         return response
 
@@ -822,6 +845,7 @@ class Martin(api_pb2_grpc.MartinServicer):
         response = api_pb2.CancelOrderResponse()
         open_client = OpenClient.get_client(request.client_id)
         client = open_client.client
+        _queue = client.on_order_update_queues.get(request.trade_id)
         try:
             res = await client.cancel_order(
                 request.trade_id,
@@ -842,7 +866,10 @@ class Martin(api_pb2_grpc.MartinServicer):
             _context.set_details(f"{ex}")
             _context.set_code(grpc.StatusCode.UNKNOWN)
         else:
-            json_format.ParseDict(res, response)
+            if float(res['executedQty']):
+                await self.create_trade_stream_event(_queue, client, open_client, request)
+                await asyncio.sleep(HEARTBEAT)
+            json_format.ParseDict(res, response, ignore_unknown_fields=True)
         return response
 
     async def TransferToMaster(self, request: api_pb2.MarketRequest,