feat: converted candles method

Author: Insmael

cryptomarket/args.py

@@ -201,10 +201,10 @@ def clean_nones(a_dict: Dict[Any, Optional[Any]]) -> Dict[Any, Any]:
 
 class DictBuilder:
     def __init__(self):
-        self.the_dict = dict()
+        self.the_dict = {}
 
     def build(self):
-        orderedDict = dict()
+        orderedDict = {}
         for parameter in sorted(self.the_dict):
             orderedDict[parameter] = self.the_dict[parameter]
         return orderedDict

cryptomarket/client.py

@@ -11,6 +11,8 @@
                                       Price, PriceHistory, SubAccount, Symbol,
                                       Ticker, Trade, Transaction, Fee)
 from cryptomarket.dataclasses.aclSettings import ACLSettings
+from cryptomarket.dataclasses.convertedCandles import ConvertedCandles
+from cryptomarket.dataclasses.convertedCandlesOfSymbol import ConvertedCandlesOfSymbol
 from cryptomarket.dataclasses.publicTrade import PublicTrade
 from cryptomarket.http_client import HttpClient
 
@@ -30,7 +32,6 @@ def __init__(self, api_key: Optional[str] = None, secret_key: Optional[str] = No
         self.get_trades_by_symbol = self.get_trades_of_symbol
         # aliases of orders
         self.create_new_order = self.create_spot_order
-        self.create_spot_order = self.create_spot_order
         self.create_new_spot_order = self.create_spot_order
 
     def close(self):
@@ -458,6 +459,92 @@ def get_candles_of_symbol(
         return [from_dict(data_class=Candle, data=candle_data)
                 for candle_data in response]
 
+    def get_converted_candles(
+        self,
+        target_currency: str,
+        symbols: Optional[List[str]] = None,
+        period: Optional[Union[
+            args.Period, Literal[
+                'M1', 'M3', 'M15', 'M30', 'H1', 'H4', 'D1', 'D7', '1M'
+            ]
+        ]] = None,
+        sort: Optional[Union[args.Sort, Literal['ASC', 'DESC']]] = None,
+        since: str = None,
+        till: str = None,
+        limit: int = None
+    ) -> ConvertedCandles:
+        """Gets candles regarding the last price converted to the target currency for all symbols or for the specified symbols
+
+        Candles are used for OHLC representation
+
+        The result contains candles with non-zero volume only (no trades = no candles).
+
+        Conversion from the symbol quote currency to the target currency is the mean of "best" bid price and "best" ask price in the order book. If there is no "best" bid of ask price, the last price is returned.
+
+        Requires no API key Access Rights.
+
+        https://api.exchange.cryptomkt.com/#candles
+
+        :param target_currency: Target currency for conversion
+        :param symbols: Optional. A list of symbol ids. If empty then gets for all symbols
+        :param period: Optional. A valid tick interval. 'M1' (one minute), 'M3', 'M5', 'M15', 'M30', 'H1' (one hour), 'H4', 'D1' (one day), 'D7', '1M' (one month). Default is 'M30'
+        :param sort: Optional. Sort direction. 'ASC' or 'DESC'. Default is 'DESC'
+        :param from: Optional. Initial value of the queried interval. As DateTime
+        :param till: Optional. Last value of the queried interval. As DateTime
+        :param limit: Optional. Prices per currency pair. Defaul is 100. Min is 1. Max is 1000
+
+        :returns: A list of candles of a symbol
+        """
+        params = args.DictBuilder().target_currency(target_currency).symbols(symbols).period(period).sort(sort).since(
+            since).till(till).limit(limit).build()
+        response = self._get(
+            endpoint="public/converted/candles", params=params)
+        return from_dict(ConvertedCandles, response)
+
+    def get_converted_candles_of_symbol(
+        self,
+        target_currency: str,
+        symbol: str,
+        period: Optional[Union[
+            args.Period, Literal[
+                'M1', 'M3', 'M15', 'M30', 'H1', 'H4', 'D1', 'D7', '1M'
+            ]
+        ]] = None,
+        sort: Optional[Union[args.Sort, Literal['ASC', 'DESC']]] = None,
+        since: str = None,
+        till: str = None,
+        limit: int = None,
+        offset: int = None
+    ) -> ConvertedCandlesOfSymbol:
+        """Gets candles regarding the last price converted to the target currency for the specified symbols
+
+        Candles are used for OHLC representation
+
+        The result contains candles with non-zero volume only (no trades = no candles).
+
+        Conversion from the symbol quote currency to the target currency is the mean of "best" bid price and "best" ask price in the order book. If there is no "best" bid of ask price, the last price is returned.
+
+        Requires no API key Access Rights.
+
+        https://api.exchange.cryptomkt.com/#candles
+
+        :param target_currency: Target currency for conversion
+        :param symbol: A symbol id
+        :param period: Optional. A valid tick interval. 'M1' (one minute), 'M3', 'M5', 'M15', 'M30', 'H1' (one hour), 'H4', 'D1' (one day), 'D7', '1M' (one month). Default is 'M30'
+        :param sort: Optional. Sort direction. 'ASC' or 'DESC'. Default is 'DESC'
+        :param from: Optional. Initial value of the queried interval. As DateTime
+        :param till: Optional. Last value of the queried interval. As DateTime
+        :param limit: Optional. Prices per currency pair. Defaul is 100. Min is 1. Max is 1000
+        :param offset: Optional. Default is 0. Min is 0. Max is 100000
+
+        :returns: A list of candles of a symbol
+        """
+        params = args.DictBuilder().target_currency(target_currency).period(period).sort(sort).since(
+            since).till(till).limit(limit).offset(offset).build()
+        response = self._get(
+            endpoint=f"public/converted/candles/{symbol}", params=params)
+        return from_dict(ConvertedCandlesOfSymbol, response)
+
     #################
     # AUTHENTICATED #
     #################

cryptomarket/dataclasses/convertedCandles.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+from typing import Dict, List
+from cryptomarket.dataclasses.candle import Candle
+
+
+@dataclass
+class ConvertedCandles:
+    target_currency: str
+    data: Dict[str, List[Candle]]

cryptomarket/dataclasses/convertedCandlesOfSymbol.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+from typing import List
+
+from cryptomarket.dataclasses.candle import Candle
+
+
+@dataclass
+class ConvertedCandlesOfSymbol:
+    target_currency: str
+    data: List[Candle]

cryptomarket/websockets/callback_cache.py

@@ -4,7 +4,7 @@
 
 class CallbackCache:
     def __init__(self):
-        self.callbacks: Dict[str, ReusableCallback] = dict()
+        self.callbacks: Dict[str, ReusableCallback] = {}
         self._id = 1
 
     def next_id(self):

cryptomarket/websockets/market_data_client.py

@@ -102,7 +102,7 @@ def subscribe_to_trades(
         params = args.DictBuilder().symbols_as_list(symbols).limit(limit).build()
 
         def intercept_feed(feed, feed_type):
-            result = dict()
+            result = {}
             for key in feed:
                 result[key] = [from_dict(data_class=WSTrade, data=data)
                                for data in feed[key]]
@@ -129,7 +129,7 @@ def subscribe_to_candles(
     ):
         """subscribe to a feed of candles
 
-        subscription is for the specified symbols
+        subscription is only for the specified symbols
 
         normal subscriptions have one update message per symbol
 
@@ -140,12 +140,12 @@ def subscribe_to_candles(
 
         :param callback: callable that recieves a dict of candles, indexed by symbol.
         :param symbols: A list of symbol ids to subscribe to
-        :param period: Optional. A valid tick interval. 'M1' (one minute), 'M3', 'M5', 'M15', 'M30', 'H1' (one hour), 'H4', 'D1' (one day), 'D7', '1M' (one month). Default is 'M30'
+        :param period: Optional. A valid tick interval. 'M1' (one minute), 'M3', 'M5', 'M15', 'M30', 'H1' (one hour), 'H4', 'D1' (one day), 'D7', '1M' (one month).
         :param limit: Number of historical entries returned in the first feed. Min is 0. Max is 1000. Default is 0
         :param result_callback: A callable of two arguments, takes either a CryptomarketAPIException, or the list of correctly subscribed symbols
         """
         def intercept_feed(feed, feed_type):
-            result = dict()
+            result = {}
             for key in feed:
                 result[key] = [
                     from_dict(data_class=WSCandle, data=data) for data in feed[key]]
@@ -158,6 +158,51 @@ def intercept_feed(feed, feed_type):
             result_callback=result_callback,
         )
 
+    def subscribe_to_converted_candles(
+        self,
+        callback: Callable[[Dict[str, List[WSCandle]], Literal['snapshot', 'update']], None],
+        target_currency: str,
+        symbols: List[str],
+        period: Union[args.Period,
+                      Literal['M1', 'M3', 'M15', 'M30', 'H1', 'H4', 'D1', 'D7', '1M']] = None,
+        limit: Optional[int] = None,
+        result_callback: Optional[Callable[[
+            Union[CryptomarketAPIException, None], Union[List[str], None]], None]] = None,
+    ):
+        """subscribes to a feed of candles regarding the last price converted to the target currency for the specified symbols
+
+        subscription is only for the specified symbols
+
+        normal subscriptions have one update message per symbol
+
+        Conversion from the symbol quote currency to the target currency is the mean of "best" bid price and "best" ask price in the order book. If there is no "best" bid or ask price, the last price is returned.
+
+        Requires no API key Access Rights
+
+        https://api.exchange.cryptomkt.com/#subscribe-to-converted-candles
+
+
+        :param callback: callable that recieves a dict of candles, indexed by symbol.
+        :param symbols: A list of symbol ids to subscribe to
+        :param period: A valid tick interval. 'M1' (one minute), 'M3', 'M5', 'M15', 'M30', 'H1' (one hour), 'H4', 'D1' (one day), 'D7', '1M' (one month).
+        :param limit: Limit of returned entries. Min is 0. Max is 1000. Default is 0
+        :param result_callback: A callable of two arguments, takes either a CryptomarketAPIException, or the list of correctly subscribed symbols
+        """
+        def intercept_feed(feed, feed_type):
+            result = {}
+            for key in feed:
+                result[key] = [
+                    from_dict(data_class=WSCandle, data=data) for data in feed[key]]
+            callback(result, feed_type)
+        params = args.DictBuilder().target_currency(
+            target_currency).symbols_as_list(symbols).limit(limit).build()
+        self._send_channeled_subscription(
+            channel=f'converted/candles/{period}',
+            callback=intercept_feed,
+            params=params,
+            result_callback=result_callback,
+        )
+
     def subscribe_to_mini_ticker(
         self,
         callback: Callable[[Dict[str, WSMiniTicker]], None],
@@ -510,7 +555,8 @@ def subscribe_to_price_rates(
         """
         if currencies is None:
             currencies = ['*']
-        params = args.DictBuilder().currencies_as_list(currencies).speed(speed).target_currency(target_currency).build()
+        params = args.DictBuilder().currencies_as_list(currencies).speed(
+            speed).target_currency(target_currency).build()
 
         def intercept_feed(feed, feed_type):
             callback({key: from_dict(data_class=WSPriceRate, data=feed[key])
@@ -521,3 +567,41 @@ def intercept_feed(feed, feed_type):
             params=params,
             result_callback=result_callback
         )
+
+    def subscribe_to_price_rates_in_batches(
+        self,
+        callback: Callable[[Dict[str, WSPriceRate]], None],
+        speed: Union[args.PriceRateSpeed, Literal['1s', '3s']],
+        target_currency: Optional[str],
+        currencies: Optional[List[str]] = None,
+        result_callback: Optional[Callable[[
+            Union[CryptomarketAPIException, None], Union[List[str], None]], None]] = None,
+    ):
+        """subscribe to a feed of price rates
+
+        subscription is for all currencies or specified currencies (bases), against a target currency (quote). indexed by currency id (bases)
+
+        batch subscriptions have a joined update for all symbols
+
+        https://api.exchange.cryptomkt.com/#subscribe-to-price-rates
+
+        :param callback: callable that recieves a dict of mini tickers, indexed by symbol.
+        :param speed: The speed of the feed. '1s' or '3s'
+        :param target_currency: quote currency for the price rates
+        :param currencies: Optional. A list of currencies ids (as bases) to subscribe to. If not provided it subscribes to all currencies
+        :param result_callback: A callable of two arguments, takes either a CryptomarketAPIException, or the list of correctly subscribed currencies
+        """
+        if currencies is None:
+            currencies = ['*']
+        params = args.DictBuilder().currencies_as_list(currencies).speed(
+            speed).target_currency(target_currency).build()
+
+        def intercept_feed(feed, feed_type):
+            callback({key: from_dict(data_class=WSPriceRate, data=feed[key])
+                      for key in feed})
+        self._send_channeled_subscription(
+            channel=f'price/rate/{speed}/batch',
+            callback=intercept_feed,
+            params=params,
+            result_callback=result_callback
+        )

cryptomarket/websockets/orderbook_cache.py

@@ -16,8 +16,8 @@ class SideOrder(Enum):
 
 class OrderbookCache:
     def __init__(self):
-        self.orderbooks = dict()
-        self.ob_states = dict()
+        self.orderbooks = {}
+        self.ob_states = {}
 
     def update(self, method: str, key:str, new_data: dict):
         if method == methodSnapshotOrderbook:

tests/rest/test_public.py tests/rest/test_market_data.pytests/rest/test_public.py renamed to tests/rest/test_market_data.py

@@ -213,11 +213,7 @@ def test_get_ticker_price(self):
 
 class GetTrades(PublicCallsTestCase):
     def test_get_trades_of_all_symbols(self):
-        symbols = self.client.get_symbols()
-        n_symbols = len(symbols)
         trades = self.client.get_trades()
-        self.assertEqual(len(trades), n_symbols,
-                         'should have trades from all symbols')
         for key in trades:
             if not good_list(good_public_trade, trades[key]):
                 self.fail("not a good trade")
@@ -262,11 +258,7 @@ def test_since_id(self):
 
 class GetOrderBooks(PublicCallsTestCase):
     def test_get_all_symbols(self):
-        symbols = self.client.get_symbols()
-        n_symbols = len(symbols)
         orderbooks = self.client.get_order_books()
-        self.assertEqual(len(orderbooks), n_symbols,
-                         "should have one orderbook per symbol")
         for key in orderbooks:
             orderbook_of_symbol = orderbooks[key]
             if not good_orderbook(orderbook_of_symbol):
@@ -309,11 +301,7 @@ def test_get_orderbook(self):
 
 class GetCandles(PublicCallsTestCase):
     def test_get_all_symbols(self):
-        symbols = self.client.get_candles()
-        n_symbols = len(symbols)
         candles = self.client.get_candles()
-        self.assertEqual(len(candles), n_symbols,
-                         "should have one candle per symbol")
         for key in candles:
             if not good_list(good_candle, candles[key]):
                 self.fail("not good candles")
@@ -328,5 +316,47 @@ def test_one_symbol(self):
         self.assertEqual(len(candles), 1, "should have one candles")
 
 
+class GetConvertedCandles(PublicCallsTestCase):
+    def test_get_all_symbols(self):
+        target_currency = "BTC"
+        converted_candles = self.client.get_converted_candles(target_currency)
+        self.assertEqual(converted_candles.target_currency, target_currency)
+        for key in converted_candles.data:
+            if not good_list(good_candle, converted_candles.data[key]):
+                self.fail("not good candles")
+
+    def test_get_many_symbols(self):
+        target_currency = "BTC"
+        converted_candles = self.client.get_converted_candles(
+            target_currency, ["EOSETH", "ETHBTC", "CROBTC"])
+        self.assertEqual(converted_candles.target_currency, target_currency)
+        for key in converted_candles.data:
+            if not good_list(good_candle, converted_candles.data[key]):
+                self.fail("not good candles")
+        self.assertEqual(len(converted_candles.data),
+                         3, "should have two candles")
+
+    def test_one_symbol(self):
+        target_currency = "BTC"
+        converted_candles = self.client.get_converted_candles(
+            target_currency, ["CROBTC"])
+        self.assertEqual(converted_candles.target_currency, target_currency)
+        for key in converted_candles.data:
+            if not good_list(good_candle, converted_candles.data[key]):
+                self.fail("not good candles")
+        self.assertEqual(len(converted_candles.data),
+                         1, "should have two candles")
+
+
+class GetConvertedCandlesOfSymbol(PublicCallsTestCase):
+    def test_get_all_symbols(self):
+        target_currency = "BTC"
+        converted_candles = self.client.get_converted_candles_of_symbol(
+            target_currency, symbol="CROETH")
+        self.assertEqual(converted_candles.target_currency, target_currency)
+        if not good_list(good_candle, converted_candles.data):
+            self.fail("not good candles")
+
+
 if __name__ == '__main__':
     unittest.main()