Merge pull request #1991 from Drakkar-Software/dev

Herklos · web-flow · commit 316f5527c1b1 · 2022-07-14T10:37:07.000+02:00
Update master
diff --git a/README.md b/README.md
@@ -111,10 +111,11 @@ In short :
 [![Binance](../assets/okex-logo.png)](https://octobot.click/gh-okex)
 [![Binance](../assets/gateio-logo.png)](https://octobot.click/gh-gateio)
 [![Binance](../assets/huobi-logo.png)](https://octobot.click/gh-huobi)
-[![Bitmax](../assets/ascendex-logo.png)](https://octobot.click/gh-ascendex)
+[![Hollaex](../assets/hollaex-logo.png)](https://octobot.click/gh-hollaex)
 [![Coinbase](../assets/coinbasepro-logo.png)](https://pro.coinbase.com)
 [![Kucoin](../assets/kucoin-logo.png)](https://www.kucoin.com)
 [![Bitmex](../assets/bitmex-logo.png)](https://bitmex.com)
+[![Bitmax](../assets/ascendex-logo.png)](https://octobot.click/gh-ascendex)
 
 Octobot supports many [exchanges](https://octobot.click/gh-exchanges) thanks to the [ccxt library](https://github.com/ccxt/ccxt). 
 To activate trading on an exchange, just configure OctoBot with your api keys as described [on the exchange documentation](https://www.octobot.online/guides/#exchanges).
diff --git a/octobot/backtesting/independent_backtesting.pxd b/octobot/backtesting/independent_backtesting.pxd
@@ -61,3 +61,4 @@ cdef class IndependentBacktesting:
     cdef str _find_reference_market(self)
     cdef void _add_config_default_backtesting_values(self)
     cdef void _add_crypto_currencies_config(self)
+    cdef void _init_exchange_type(self)
diff --git a/octobot/backtesting/independent_backtesting.py b/octobot/backtesting/independent_backtesting.py
@@ -23,7 +23,7 @@
 import octobot_commons.errors as errors
 import octobot_commons.logging as commons_logging
 import octobot_commons.pretty_printer as pretty_printer
-import octobot_commons.symbol_util as symbol_util
+import octobot_commons.symbols.symbol_util as symbol_util
 import octobot_commons.databases as databases
 import octobot_commons.optimization_campaign as optimization_campaign
 import octobot_commons.time_frame_manager as time_frame_manager
@@ -37,6 +37,7 @@
 import octobot_evaluators.constants as evaluator_constants
 
 import octobot_trading.api as trading_api
+import octobot_trading.enums as trading_enums
 
 
 class IndependentBacktesting:
@@ -165,7 +166,7 @@ async def _post_backtesting_end_callback(self):
     @staticmethod
     def _get_market_delta(symbol, exchange_manager, min_timeframe):
         market_data = trading_api.get_symbol_historical_candles(
-            trading_api.get_symbol_data(exchange_manager, symbol), min_timeframe)
+            trading_api.get_symbol_data(exchange_manager, symbol.legacy_symbol()), min_timeframe)
         market_begin = market_data[enums.PriceIndexes.IND_PRICE_CLOSE.value][0]
         market_end = market_data[enums.PriceIndexes.IND_PRICE_CLOSE.value][-1]
 
@@ -186,7 +187,7 @@ async def _register_available_data(self):
             if exchange_name not in self.symbols_to_create_exchange_classes:
                 self.symbols_to_create_exchange_classes[exchange_name] = []
             for symbol in description[backtesting_enums.DataFormatKeys.SYMBOLS.value]:
-                self.symbols_to_create_exchange_classes[exchange_name].append(symbol)
+                self.symbols_to_create_exchange_classes[exchange_name].append(symbol_util.parse_symbol(symbol))
 
     def _init_default_config_values(self):
         self.risk = copy.deepcopy(self.octobot_origin_config[common_constants.CONFIG_TRADING][
@@ -241,9 +242,9 @@ def _get_exchanges_report(self, reference_market, trading_mode):
             exchange_name = trading_api.get_exchange_name(exchange_manager)
             for symbol in self.symbols_to_create_exchange_classes[exchange_name]:
                 market_delta = self._get_market_delta(symbol, exchange_manager, min_timeframe)
-                report[SYMBOL_REPORT].append({symbol: market_delta * 100})
+                report[SYMBOL_REPORT].append({symbol.symbol_str: market_delta * 100})
                 report[CHART_IDENTIFIERS].append({
-                    "symbol": symbol,
+                    "symbol": symbol.symbol_str,
                     "exchange_id": exchange_id,
                     "exchange_name": exchange_name,
                     "time_frame": min_timeframe.value
@@ -286,7 +287,7 @@ def _log_trades_history(self, exchange_manager, exchange_name):
 
     def _log_symbol_report(self, symbol, exchange_manager, min_time_frame):
         market_delta = self._get_market_delta(symbol, exchange_manager, min_time_frame)
-        self.logger.info(f"{symbol} Profitability : {market_delta * 100}%")
+        self.logger.info(f"{symbol.symbol_str} Profitability : {market_delta * 100}%")
 
     def _log_global_report(self, exchange_manager):
         _, profitability, _, market_average_profitability, _ = trading_api.get_profitability_stats(exchange_manager)
@@ -310,6 +311,14 @@ def _log_global_report(self, exchange_manager):
             f"{round(backtesting_api.get_backtesting_duration(self.octobot_backtesting.backtesting), 3)} sec")
 
     def _adapt_config(self):
+        self._init_exchange_type()
+        self.backtesting_config[common_constants.CONFIG_EXCHANGES] = copy.deepcopy(
+            self.octobot_origin_config[common_constants.CONFIG_EXCHANGES])
+        for exchange_details in self.backtesting_config[common_constants.CONFIG_EXCHANGES].values():
+            exchange_details.pop(common_constants.CONFIG_EXCHANGE_KEY, None)
+            exchange_details.pop(common_constants.CONFIG_EXCHANGE_SECRET, None)
+            exchange_details.pop(common_constants.CONFIG_EXCHANGE_PASSWORD, None)
+            exchange_details.pop(common_constants.CONFIG_EXCHANGE_SANDBOXED, None)
         self.backtesting_config[common_constants.CONFIG_TRADING][common_constants.CONFIG_TRADER_RISK] = self.risk
         self.backtesting_config[common_constants.CONFIG_TRADING][
             common_constants.CONFIG_TRADER_REFERENCE_MARKET] = self._find_reference_market()
@@ -323,6 +332,17 @@ def _adapt_config(self):
             self.backtesting_config[evaluator_constants.CONFIG_FORCED_TIME_FRAME] = self.forced_time_frames
         self._add_config_default_backtesting_values()
 
+    def _init_exchange_type(self):
+        try:
+            for exchange_name in self.symbols_to_create_exchange_classes:
+                # use current profile config to create a spot/future/margin backtesting exchange
+                self.octobot_backtesting.exchange_type_by_exchange[exchange_name] = \
+                    self.octobot_origin_config[common_constants.CONFIG_EXCHANGES].get(exchange_name, {}).\
+                    get(common_constants.CONFIG_EXCHANGE_TYPE, common_constants.DEFAULT_EXCHANGE_TYPE)
+        except StopIteration:
+            # use default exchange type
+            pass
+
     async def _generate_backtesting_id_if_missing(self):
         if self.backtesting_config[common_constants.CONFIG_BACKTESTING_ID] is None:
             run_dbs_identifier = databases.RunDatabasesIdentifier(
@@ -337,25 +357,31 @@ async def _generate_backtesting_id_if_missing(self):
     def _find_reference_market(self):
         ref_market_candidate = None
         ref_market_candidates = {}
-        for pairs in self.symbols_to_create_exchange_classes.values():
-            if self.octobot_backtesting.is_future and \
-               trading_api.is_inverse_future_contract(self.octobot_backtesting.futures_contract_type):
-                if len(pairs) > 1:
-                    self.logger.error(f"Only one trading pair is supported in inverse contracts backtesting. "
-                                      f"Found: the following pairs: {pairs}")
+        for symbols in self.symbols_to_create_exchange_classes.values():
+            symbol = symbols[0]
+            if next(iter(self.octobot_backtesting.exchange_type_by_exchange.values())) \
+                    == common_constants.CONFIG_EXCHANGE_FUTURE:
+                if symbol.is_inverse():
+                    if not all([symbol.is_inverse() for symbol in symbols]):
+                        self.logger.error(f"Mixed inverse and linear contracts backtesting are not supported yet")
+                    self.octobot_backtesting.futures_contract_type = trading_enums.FutureContractType.INVERSE_PERPETUAL
+                else:
+                    if not all([symbol.is_linear() for symbol in symbols]):
+                        self.logger.error(f"Mixed inverse and linear contracts backtesting are not supported yet")
+                    self.octobot_backtesting.futures_contract_type = trading_enums.FutureContractType.LINEAR_PERPETUAL
                 # in inverse contracts, use BTC for BTC/USD trading as reference market
-                return symbol_util.split_symbol(pairs[0])[0]
-            for pair in pairs:
-                base = symbol_util.split_symbol(pair)[1]
+                return symbol.settlement_asset
+            for symbol in symbols:
+                quote = symbol.quote
                 if ref_market_candidate is None:
-                    ref_market_candidate = base
-                if base in ref_market_candidates:
-                    ref_market_candidates[base] += 1
+                    ref_market_candidate = quote
+                if quote in ref_market_candidates:
+                    ref_market_candidates[quote] += 1
                 else:
-                    ref_market_candidates[base] = 1
-                if ref_market_candidate != base and \
-                        ref_market_candidates[ref_market_candidate] < ref_market_candidates[base]:
-                    ref_market_candidate = base
+                    ref_market_candidates[quote] = 1
+                if ref_market_candidate != quote and \
+                        ref_market_candidates[ref_market_candidate] < ref_market_candidates[quote]:
+                    ref_market_candidate = quote
         return ref_market_candidate
 
     def _add_config_default_backtesting_values(self):
@@ -366,11 +392,12 @@ def _add_config_default_backtesting_values(self):
         self.backtesting_config[common_constants.CONFIG_SIMULATOR][common_constants.CONFIG_ENABLED_OPTION] = True
 
     def _add_crypto_currencies_config(self):
-        for pairs in self.symbols_to_create_exchange_classes.values():
-            for pair in pairs:
-                if pair not in self.backtesting_config[common_constants.CONFIG_CRYPTO_CURRENCIES]:
-                    self.backtesting_config[common_constants.CONFIG_CRYPTO_CURRENCIES][pair] = {
+        for symbols in self.symbols_to_create_exchange_classes.values():
+            for symbol in symbols:
+                symbol_id = symbol.legacy_symbol()
+                if symbol_id not in self.backtesting_config[common_constants.CONFIG_CRYPTO_CURRENCIES]:
+                    self.backtesting_config[common_constants.CONFIG_CRYPTO_CURRENCIES][symbol_id] = {
                         common_constants.CONFIG_CRYPTO_PAIRS: []
                     }
-                    self.backtesting_config[common_constants.CONFIG_CRYPTO_CURRENCIES][pair][
-                        common_constants.CONFIG_CRYPTO_PAIRS] = [pair]
+                    self.backtesting_config[common_constants.CONFIG_CRYPTO_CURRENCIES][symbol_id][
+                        common_constants.CONFIG_CRYPTO_PAIRS] = [symbol_id]
diff --git a/octobot/backtesting/octobot_backtesting.pxd b/octobot/backtesting/octobot_backtesting.pxd
@@ -35,7 +35,7 @@ cdef class OctoBotBacktesting:
     cdef public object start_timestamp
     cdef public object end_timestamp
     cdef public bint enable_logs
-    cdef public bint is_future
+    cdef public dict exchange_type_by_exchange
     cdef public object futures_contract_type
 
     cpdef object memory_leak_checkup(self, list to_check_elements)
diff --git a/octobot/backtesting/octobot_backtesting.py b/octobot/backtesting/octobot_backtesting.py
@@ -63,7 +63,7 @@ def __init__(self, backtesting_config,
         self.start_timestamp = start_timestamp
         self.end_timestamp = end_timestamp
         self.enable_logs = enable_logs
-        self.is_future = False
+        self.exchange_type_by_exchange = {}
         self.futures_contract_type = trading_enums.FutureContractType.LINEAR_PERPETUAL
 
     async def initialize_and_run(self):
@@ -232,14 +232,16 @@ async def _init_exchanges(self):
                                                          end_timestamp=self.end_timestamp)
 
         for exchange_class_string in self.symbols_to_create_exchange_classes.keys():
+            is_future = self.exchange_type_by_exchange[exchange_class_string] == \
+                        commons_constants.CONFIG_EXCHANGE_FUTURE
             exchange_builder = trading_api.create_exchange_builder(self.backtesting_config, exchange_class_string) \
                 .has_matrix(self.matrix_id) \
                 .use_tentacles_setup_config(self.tentacles_setup_config) \
                 .set_bot_id(self.bot_id) \
                 .is_simulated() \
                 .is_rest_only() \
-                .is_future(self.is_future, self.futures_contract_type) \
-                .is_backtesting(self.backtesting)
+                .is_backtesting(self.backtesting) \
+                .is_future(is_future, self.futures_contract_type)
             try:
                 await exchange_builder.build()
             finally:
diff --git a/octobot/cli.py b/octobot/cli.py
@@ -128,11 +128,13 @@ def _create_startup_config(logger):
 
 def _read_config(config, logger):
     try:
-        config.read(should_raise=False, fill_missing_fields=True)
+        config.read(should_raise=True, fill_missing_fields=True)
     except errors.NoProfileError:
         _repair_with_default_profile(config, logger)
         config = _create_configuration()
         config.read(should_raise=False, fill_missing_fields=True)
+    except Exception as e:
+        raise errors.ConfigError(e)
 
 
 def _validate_config(config, logger):
@@ -245,9 +247,9 @@ def start_octobot(args):
 
         commands.run_bot(bot, logger)
 
-    except errors.ConfigError:
+    except errors.ConfigError as e:
         logger.error("OctoBot can't start without a valid " + common_constants.CONFIG_FILE
-                     + " configuration file." + "\nYou can use " +
+                     + " configuration file.\nError: " + str(e) + "\nYou can use " +
                      constants.DEFAULT_CONFIG_FILE + " as an example to fix it.")
         os._exit(-1)
 
diff --git a/octobot/community/community_manager.py b/octobot/community/community_manager.py
@@ -22,7 +22,7 @@
 import octobot_commons.logging as logging
 import octobot_commons.configuration as configuration
 import octobot_commons.os_util as os_util
-import octobot_commons.symbol_util as symbol_util
+import octobot_commons.symbols.symbol_util as symbol_util
 import octobot_commons.authentication as authentication
 
 import octobot_commons.constants as common_constants
@@ -179,7 +179,7 @@ def _get_traded_volumes(self):
                 trades += trading_api.get_trade_history(exchange_manager, since=self.octobot_api.get_start_time())
             for trade in trades:
                 # cost is in quote currency for a traded pair
-                currency = symbol_util.split_symbol(trade.symbol)[-1]
+                currency = symbol_util.parse_symbol(trade.symbol).quote
                 if currency in volume_by_currency:
                     volume_by_currency[currency] += float(trade.total_cost)
                 else:
diff --git a/octobot/config/profile_schema.json b/octobot/config/profile_schema.json
@@ -62,6 +62,9 @@
               "properties": {
                 "enabled": {
                   "type": "boolean"
+                },
+                "exchange-type": {
+                  "type": "string"
                 }
               },
               "required": [
diff --git a/octobot/constants.py b/octobot/constants.py
@@ -28,7 +28,7 @@
 
 # OctoBot urls
 OCTOBOT_WEBSITE_URL = os.getenv("OCTOBOT_ONLINE_URL", "https://www.octobot.online")
-OCTOBOT_DOCS_URL = os.getenv("DOCS_OCTOBOT_ONLINE_URL", "https://octobot.info")
+OCTOBOT_DOCS_URL = os.getenv("DOCS_OCTOBOT_ONLINE_URL", "https://www.octobot.info")
 EXCHANGES_DOCS_URL = os.getenv("DOCS_OCTOBOT_ONLINE_URL", "https://exchanges.octobot.info/")
 DEVELOPER_DOCS_URL = os.getenv("DOCS_OCTOBOT_ONLINE_URL", "https://developer.octobot.info/")
 OCTOBOT_ONLINE = os.getenv("TENTACLES_OCTOBOT_ONLINE_URL", "https://static.octobot.online")
diff --git a/requirements.txt b/requirements.txt
@@ -2,12 +2,12 @@
 cython==0.29.26
 
 # Drakkar-Software requirements
-OctoBot-Commons==1.7.8
-OctoBot-Trading==2.2.6
-OctoBot-Evaluators==1.7.3
+OctoBot-Commons==1.7.10
+OctoBot-Trading==2.2.7
+OctoBot-Evaluators==1.7.4
 OctoBot-Tentacles-Manager==2.7.0
-OctoBot-Services==1.3.1
-OctoBot-Backtesting==1.7.1
+OctoBot-Services==1.3.2
+OctoBot-Backtesting==1.7.2
 Async-Channel==2.0.13
 trading-backend==1.0.13
 
