feat: websocket order lists multiple response

Author: Insmael

cryptomarket/dataclasses/report.py

@@ -31,7 +31,7 @@ class Report:
     post_only: bool
     created_at: str
     updated_at: str
-    report_type: ReportType
+    report_type: Optional[ReportType] = None
     price: Optional[str] = None
     stop_price: Optional[str] = None
     expire_time: Optional[str] = None

cryptomarket/websockets/callback_cache.py

@@ -1,33 +1,40 @@
+from typing import Callable, Dict, Optional
+from cryptomarket.websockets.reusable_callback import ReusableCallback
+
+
 class CallbackCache:
     def __init__(self):
-        self.callbacks = dict()
+        self.callbacks: Dict[str, ReusableCallback] = dict()
         self._id = 1
-    
+
     def next_id(self):
         self._id += 1
         if self._id < 1:
             self._id = 1
         return self._id
 
-    def store_callback(self, callback: callable) -> int:
+    def save_callback(self, callback: callable, call_count: int = 1) -> int:
         id = self.next_id()
-        self.callbacks[id] = callback
+        self.callbacks[id] = ReusableCallback(callback, call_count)
         return id
 
-    def pop_callback(self, id: int) -> callable:
-        if id not in self.callbacks: return None
-        callback = self.callbacks[id]
-        del self.callbacks[id]
+    def get_callback(self, id: int) -> Optional[Callable]:
+        if id not in self.callbacks:
+            return None
+        reusable_callback = self.callbacks[id]
+        callback, done = reusable_callback.get_callback()
+        if done:
+            del self.callbacks[id]
         return callback
 
-    def store_subscription_callback(self, key: str, callback: callable):
+    def save_subscription_callback(self, key: str, callback: callable):
         self.callbacks[key] = callback
 
     def get_subscription_callback(self, key: str) -> callable:
-        if key not in self.callbacks: return None
+        if key not in self.callbacks:
+            return None
         return self.callbacks[key]
 
     def delete_subscription_callback(self, key: str):
-        if key in self.callbacks: del self.callbacks[key]
-        
-
+        if key in self.callbacks:
+            del self.callbacks[key]

cryptomarket/websockets/client_base.py

@@ -71,18 +71,18 @@ def _on_open(self):
 
     def _send_subscription(self, method, callback, params=None, result_callback=None):
         key = self._build_key(method)
-        self._callback_cache.store_subscription_callback(key, callback)
+        self._callback_cache.save_subscription_callback(key, callback)
         self._send_by_id(method, result_callback, params)
 
     def _send_unsubscription(self, method, callback=None, params=None):
         key = self._build_key(method)
         self._callback_cache.delete_subscription_callback(key)
         self._send_by_id(method, callback, params)
 
-    def _send_by_id(self, method: str, callback: callable = None, params=None):
+    def _send_by_id(self, method: str, callback: callable = None, params=None, call_count: int = 1):
         payload = {'method': method, 'params': params}
         if callback:
-            id = self._callback_cache.store_callback(callback)
+            id = self._callback_cache.save_callback(callback, call_count)
             payload['id'] = id
         self._ws_manager.send(payload)
 
@@ -108,10 +108,9 @@ def _handle_notification(self, message):
 
     def _handle_response(self, response):
         id = response['id']
-        callback = self._callback_cache.pop_callback(id)
+        callback = self._callback_cache.get_callback(id)
         if callback is None:
             return
-
         if 'error' in response:
             callback(CryptomarketAPIException.from_dict(response), None)
             return

cryptomarket/websockets/interceptors.py

@@ -0,0 +1,20 @@
+from enum import Enum
+from functools import partial
+from dacite import Config, from_dict
+from cryptomarket.dataclasses.report import Report
+
+
+def intercept_report(callback):
+    return partial(intercept_report_, callback=callback)
+
+
+def intercept_report_(err, response, callback):
+    print('interceptor')
+    print('err:', err)
+    print('response:', response)
+    if err:
+        callback(err, None)
+        return
+    reports = from_dict(data_class=Report, data=response,
+                        config=Config(cast=[Enum]))
+    callback(None, reports)

cryptomarket/websockets/market_data_client.py

@@ -63,11 +63,11 @@ def _send_channeled_subscription(
         result_callback=None
     ):
         key = channel
-        self._callback_cache.store_subscription_callback(key, callback)
+        self._callback_cache.save_subscription_callback(key, callback)
 
         def intercept_result(err, result):
             result_callback(err, result['subscriptions'])
-        ID = self._callback_cache.store_callback(intercept_result)
+        ID = self._callback_cache.save_callback(intercept_result)
         payload = {
             'method': 'subscribe',
             'ch': channel,

cryptomarket/websockets/reusable_callback.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+from typing import Callable, Optional, Tuple
+
+
+@dataclass
+class ReusableCallback:
+    callback: Callable
+    call_count: int
+
+    def is_done(self) -> bool:
+        return self.call_count < 1
+
+    def get_callback(self) -> Optional[Tuple[Callable, bool]]:
+        if self.is_done():
+            return None, True
+        self.call_count -= 1
+        return self.callback, self.is_done()

cryptomarket/websockets/trading_client.py

@@ -237,10 +237,12 @@ def create_spot_order_list(
         orders: List[args.OrderRequest],
         order_list_id: Optional[str] = None,
         callback: Optional[Callable[[
-            Union[CryptomarketAPIException, None], Union[List[Report], None]], None]] = None
+            Union[CryptomarketAPIException, None], Union[Report, None]], None]] = None
     ):
         """creates a list of spot orders
 
+        calls the callback once per each order in the orders list
+
         Types or Contingency:
         - Contingency.ALL_OR_NONE (Contingency.AON)
         - Contingency.ONE_CANCEL_OTHER (Contingency.OCO)
@@ -277,23 +279,22 @@ def create_spot_order_list(
         :param contingency_type: order list type.
         :param orders: the list of orders
         :param order_list_id: order list identifier. If not provided, it will be generated by the system. Must be equal to the client order id of the first order in the request
-        :param callback: A callable of two arguments, takes either a CryptomarketAPIException, or a list of reports of the created orders
+        :param callback: A callable of two arguments, takes either a CryptomarketAPIException, or a report of one of the created order. Once per created order
         """
         params = args.DictBuilder().order_list_id(
             order_list_id).contingency_type(contingency_type).orders(orders).build()
-
         if callback:
             def intercept_response(err, response):
                 if err:
                     callback(err, None)
                     return
-                reports = [from_dict(data_class=Report, data=report, config=Config(cast=[Enum]))
-                           for report in response]
-                callback(None, reports)
+                report = from_dict(data_class=Report,
+                                   data=response, config=Config(cast=[Enum]))
+                callback(None, report)
         else:
             intercept_response = None
         self._send_by_id('spot_new_order_list',
-                         callback=intercept_response, params=params)
+                         callback=intercept_response, params=params, call_count=len(orders))
 
     def cancel_spot_order(
         self,

tests/websockets/test_helpers.py

@@ -198,7 +198,7 @@ def good_report(report: Report):
             'time_in_force',
             'quantity',
             'price',
-            'cum_quantity',
+            'quantity_cumulative',
             'post_only',
             'created_at',
             'updated_at',

tests/websockets/test_trading_client.py

@@ -2,6 +2,7 @@
 import time
 import unittest
 from typing import Union
+from cryptomarket import args
 
 from test_helpers import *
 
@@ -170,6 +171,53 @@ def check_good_trading_commission(err, commission):
         if Veredict.failed:
             self.fail(Veredict.message)
 
+    def test_create_spot_order_list(self):
+        first_order_id = str(int(time.time()))
+        second_order_id = first_order_id + "2"
+        side = args.Side.SELL
+        quantity = "0.01"
+        price = "10000"
+        time_in_force = args.TimeInForce.FOK
+
+        def check_good_report(err, report):
+            if err:
+                Veredict.fail(f'{err}')
+                return
+            if not good_report(report):
+                Veredict.fail('not a good report')
+                return
+            Veredict.done = True
+        try:
+            self.ws.create_spot_order_list(
+                contingency_type=args.ContingencyType.ALL_OR_NONE,
+                order_list_id=first_order_id,
+                orders=[
+                    args.OrderRequest(
+                        'EOSETH',
+                        side=side,
+                        quantity=quantity,
+                        client_order_id=first_order_id,
+                        time_in_force=time_in_force,
+                        price=price
+                    ),
+                    args.OrderRequest(
+                        'EOSBTC',
+                        side=side,
+                        quantity=quantity,
+                        client_order_id=second_order_id,
+                        time_in_force=time_in_force,
+                        price=price
+                    ),
+                ],
+                callback=check_good_report)
+        except Exception as e:
+            print(e)
+            self.fail(str(e))
+        time.sleep(10)
+        Veredict.wait_done()
+        if Veredict.failed:
+            self.fail(Veredict.message)
+
 
 if __name__ == '__main__':
     unittest.main()