OctoBot-Trading 2.4.125__tar.gz → 2.4.127__tar.gz

{OctoBot-Trading-2.4.125 → OctoBot-Trading-2.4.127}/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.4.127] - 2023-11-28
+### Updated
+[MarketStatus] fix min cost overriding
+
+## [2.4.126] - 2023-11-24
+### Updated
+[Backtesting] make backtesting more flexible for missing data
+
 ## [2.4.125] - 2023-11-23
 ### Added
 [TradingMode] historical config

{OctoBot-Trading-2.4.125 → OctoBot-Trading-2.4.127/OctoBot_Trading.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: OctoBot-Trading
-Version: 2.4.125
+Version: 2.4.127
 Summary: OctoBot project trading package
 Home-page: https://github.com/Drakkar-Software/OctoBot-Trading
 Author: Drakkar-Software
@@ -16,7 +16,7 @@ Classifier: Operating System :: POSIX
 Requires-Python: >=3.8
 License-File: LICENSE
 
-# OctoBot-Trading [2.4.125](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.127](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/903b6b22bceb4661b608a86fea655f69)](https://app.codacy.com/gh/Drakkar-Software/OctoBot-Trading?utm_source=github.com&utm_medium=referral&utm_content=Drakkar-Software/OctoBot-Trading&utm_campaign=Badge_Grade_Dashboard)
 [![PyPI](https://img.shields.io/pypi/v/OctoBot-Trading.svg)](https://pypi.python.org/pypi/OctoBot-Trading/)
 [![Coverage Status](https://coveralls.io/repos/github/Drakkar-Software/OctoBot-Trading/badge.svg?branch=master)](https://coveralls.io/github/Drakkar-Software/OctoBot-Trading?branch=master)

{OctoBot-Trading-2.4.125 → OctoBot-Trading-2.4.127}/OctoBot_Trading.egg-info/SOURCES.txt

@@ -451,6 +451,7 @@ tests_additional/real_exchanges/test_bitfinex.py
 tests_additional/real_exchanges/test_bitget.py
 tests_additional/real_exchanges/test_bithumb.py
 tests_additional/real_exchanges/test_bitmart.py
+tests_additional/real_exchanges/test_bitmex.py
 tests_additional/real_exchanges/test_bitso.py
 tests_additional/real_exchanges/test_bitstamp.py
 tests_additional/real_exchanges/test_bybit.py

{OctoBot-Trading-2.4.125/OctoBot_Trading.egg-info → OctoBot-Trading-2.4.127}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: OctoBot-Trading
-Version: 2.4.125
+Version: 2.4.127
 Summary: OctoBot project trading package
 Home-page: https://github.com/Drakkar-Software/OctoBot-Trading
 Author: Drakkar-Software
@@ -16,7 +16,7 @@ Classifier: Operating System :: POSIX
 Requires-Python: >=3.8
 License-File: LICENSE
 
-# OctoBot-Trading [2.4.125](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.127](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/903b6b22bceb4661b608a86fea655f69)](https://app.codacy.com/gh/Drakkar-Software/OctoBot-Trading?utm_source=github.com&utm_medium=referral&utm_content=Drakkar-Software/OctoBot-Trading&utm_campaign=Badge_Grade_Dashboard)
 [![PyPI](https://img.shields.io/pypi/v/OctoBot-Trading.svg)](https://pypi.python.org/pypi/OctoBot-Trading/)
 [![Coverage Status](https://coveralls.io/repos/github/Drakkar-Software/OctoBot-Trading/badge.svg?branch=master)](https://coveralls.io/github/Drakkar-Software/OctoBot-Trading?branch=master)

{OctoBot-Trading-2.4.125 → OctoBot-Trading-2.4.127}/README.md

@@ -1,4 +1,4 @@
-# OctoBot-Trading [2.4.125](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.127](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/903b6b22bceb4661b608a86fea655f69)](https://app.codacy.com/gh/Drakkar-Software/OctoBot-Trading?utm_source=github.com&utm_medium=referral&utm_content=Drakkar-Software/OctoBot-Trading&utm_campaign=Badge_Grade_Dashboard)
 [![PyPI](https://img.shields.io/pypi/v/OctoBot-Trading.svg)](https://pypi.python.org/pypi/OctoBot-Trading/)
 [![Coverage Status](https://coveralls.io/repos/github/Drakkar-Software/OctoBot-Trading/badge.svg?branch=master)](https://coveralls.io/github/Drakkar-Software/OctoBot-Trading?branch=master)

{OctoBot-Trading-2.4.125 → OctoBot-Trading-2.4.127}/octobot_trading/__init__.py

@@ -15,4 +15,4 @@
 #  License along with this library.
 
 PROJECT_NAME = "OctoBot-Trading"
-VERSION = "2.4.125"  # major.minor.revision
+VERSION = "2.4.127"  # major.minor.revision

{OctoBot-Trading-2.4.125 → OctoBot-Trading-2.4.127}/octobot_trading/constants.py

@@ -115,6 +115,7 @@ FULL_CANDLE_HISTORY_EXCHANGES = [
     "coinbase",
     "binanceus",
     "bitmart",
+    "bitmex",
 ]
 
 DEFAULT_FUTURE_EXCHANGES = ["binanceusdm", "bybit"]
@@ -139,7 +140,7 @@ TESTED_EXCHANGES = [
     "bitmart",
 ])
 DEFAULT_FUTURE_EXCHANGES = sorted(["bybit"])
-SIMULATOR_TESTED_EXCHANGES = sorted(["bitfinex2", "bithumb", "bitstamp", "bittrex",
+SIMULATOR_TESTED_EXCHANGES = sorted(["bitfinex2", "bithumb", "bitstamp", "bitmex",
                               "hitbtc", "kraken", "poloniex", "bitso", "ndax", "upbit",
                               "wavesexchange",])
 

{OctoBot-Trading-2.4.125 → OctoBot-Trading-2.4.127}/octobot_trading/exchanges/config/exchange_config_data.py

@@ -105,18 +105,18 @@ class ExchangeConfig(util.Initializable):
                 if self.exchange_manager.is_future \
                 else trading_constants.DEFAULT_INITIALIZATION_EVENT_TOPICS:
             if topic in (
-                    commons_enums.InitializationEventExchangeTopics.POSITIONS,
-                    commons_enums.InitializationEventExchangeTopics.TRADES,
-                    commons_enums.InitializationEventExchangeTopics.ORDERS,
-                    commons_enums.InitializationEventExchangeTopics.CONTRACTS,
-                    commons_enums.InitializationEventExchangeTopics.CANDLES,
-                    commons_enums.InitializationEventExchangeTopics.PRICE,
-                    commons_enums.InitializationEventExchangeTopics.ORDER_BOOK,
-                    commons_enums.InitializationEventExchangeTopics.FUNDING,
+                commons_enums.InitializationEventExchangeTopics.POSITIONS,
+                commons_enums.InitializationEventExchangeTopics.TRADES,
+                commons_enums.InitializationEventExchangeTopics.ORDERS,
+                commons_enums.InitializationEventExchangeTopics.CONTRACTS,
+                commons_enums.InitializationEventExchangeTopics.CANDLES,
+                commons_enums.InitializationEventExchangeTopics.PRICE,
+                commons_enums.InitializationEventExchangeTopics.ORDER_BOOK,
+                commons_enums.InitializationEventExchangeTopics.FUNDING,
             ):
                 for symbol in self.traded_symbol_pairs:
                     if topic in (
-                            commons_enums.InitializationEventExchangeTopics.CANDLES,
+                        commons_enums.InitializationEventExchangeTopics.CANDLES,
                     ):
                         for time_frame in self.traded_time_frames:
                             tree_provider.create_event_at_path(

{OctoBot-Trading-2.4.125 → OctoBot-Trading-2.4.127}/octobot_trading/exchanges/connectors/simulator/exchange_simulator_connector.py

@@ -46,6 +46,7 @@ class ExchangeSimulatorConnector(abstract_exchange.AbstractExchange):
 
         self.is_authenticated = False
         self._forced_market_statuses: dict = None
+        self._missing_market_statuses: set = set()
 
     async def initialize_impl(self):
         self.exchange_importers = self.backtesting.get_importers(importers.ExchangeDataImporter)
@@ -150,7 +151,15 @@ class ExchangeSimulatorConnector(abstract_exchange.AbstractExchange):
                     ).market_status
                 return self._forced_market_statuses[symbol]
             except KeyError:
-                raise errors.NotSupported
+                self._missing_market_statuses.add(symbol)
+                if len(self._missing_market_statuses) >= len(self.symbols) - 1:
+                    # issue: almost all market statuses are missing
+                    raise errors.NotSupported(
+                        f"Missing too many market statuses: {self._missing_market_statuses}, "
+                        f"traded symbols: {self.symbols}"
+                    )
+                else:
+                    self.logger.warning(f"Missing cached market status for {symbol}: using default market status")
         return self._get_default_market_status()
 
     def _get_default_market_status(self):

{OctoBot-Trading-2.4.125 → OctoBot-Trading-2.4.127}/octobot_trading/exchanges/util/exchange_market_status_fixer.py

@@ -245,7 +245,7 @@ class ExchangeMarketStatusFixer:
     def _fix_market_status_limits_with_price(self):
         candidate_amount_min, candidate_amount_max = self._calculate_amount()
         limits_amount = self.market_status[Ecmsc.LIMITS.value][Ecmsc.LIMITS_AMOUNT.value]
-        amount_min = limits_amount.get(Ecmsc.LIMITS_PRICE_MIN.value)
+        amount_min = limits_amount.get(Ecmsc.LIMITS_AMOUNT_MIN.value)
         if not is_ms_valid(amount_min, zero_valid=True):
             amount_min = candidate_amount_min
         amount_max = limits_amount.get(Ecmsc.LIMITS_AMOUNT_MAX.value)
@@ -259,6 +259,28 @@ class ExchangeMarketStatusFixer:
         price_max = limits_price.get(Ecmsc.LIMITS_PRICE_MAX.value)
         if not is_ms_valid(price_max, zero_valid=False):
             price_max = self.price_example * self.LIMIT_PRICE_MULTIPLIER
+        limit_cost = self.market_status[Ecmsc.LIMITS.value].get(Ecmsc.LIMITS_COST.value, {})
+        cost_min = limit_cost.get(Ecmsc.LIMITS_COST_MIN.value)
+        if not is_ms_valid(cost_min, zero_valid=False):
+            updated_cost = False
+            if (
+                is_ms_valid(limits_price.get(Ecmsc.LIMITS_PRICE_MIN.value))
+                and is_ms_valid(limits_amount.get(Ecmsc.LIMITS_AMOUNT_MIN.value))
+            ):
+                # min cost can be computed from min price and amount: those values come from exchange data
+                candidate_cost_min = (
+                    limits_price.get(Ecmsc.LIMITS_PRICE_MIN.value)
+                    * limits_amount.get(Ecmsc.LIMITS_AMOUNT_MIN.value)
+                )
+                if is_ms_valid(candidate_cost_min, zero_valid=False):
+                    cost_min = candidate_cost_min
+                    updated_cost = True
+            if not updated_cost:
+                # avoid computing min cost based on indirect min price or amount
+                cost_min = 0
+        cost_max = limit_cost.get(Ecmsc.LIMITS_COST_MAX.value)
+        if not is_ms_valid(cost_max, zero_valid=False):
+            cost_max = price_max * amount_max
         self.market_status[Ecmsc.LIMITS.value] = {
             Ecmsc.LIMITS_AMOUNT.value: {
                 Ecmsc.LIMITS_AMOUNT_MIN.value: amount_min,
@@ -269,8 +291,8 @@ class ExchangeMarketStatusFixer:
                 Ecmsc.LIMITS_PRICE_MAX.value: price_max,
             },
             Ecmsc.LIMITS_COST.value: {
-                Ecmsc.LIMITS_COST_MIN.value: price_min * amount_min,
-                Ecmsc.LIMITS_COST_MAX.value: price_max * amount_max,
+                Ecmsc.LIMITS_COST_MIN.value: cost_min,
+                Ecmsc.LIMITS_COST_MAX.value: cost_max,
             }
         }
 

{OctoBot-Trading-2.4.125 → OctoBot-Trading-2.4.127}/octobot_trading/modes/abstract_trading_mode.py

@@ -439,8 +439,6 @@ class AbstractTradingMode(abstract_tentacle.AbstractTentacle):
 
     def update_config_and_user_inputs_if_necessary(self):
         if self.update_config_if_necessary():
-            print(f"{octobot_commons.timestamp_util.convert_timestamp_to_datetime(self.exchange_manager.exchange.get_exchange_current_time())}"
-                  f" updated config: {self.trading_config} ")
             self.init_user_inputs({})
 
     def update_config_if_necessary(self) -> bool:
@@ -463,6 +461,13 @@ class AbstractTradingMode(abstract_tentacle.AbstractTentacle):
             self.historical_master_config, self.exchange_manager.exchange.get_exchange_current_time()
         )
 
+    def has_historical_config(self) -> bool:
+        try:
+            octobot_commons.configuration.get_oldest_historical_tentacle_config_time(self.trading_config)
+            return True
+        except ValueError:
+            return False
+
     @classmethod
     def create_local_instance(cls, config, tentacles_setup_config, tentacle_config):
         return modes_factory.create_temporary_trading_mode_with_local_config(
@@ -473,6 +478,17 @@ class AbstractTradingMode(abstract_tentacle.AbstractTentacle):
     def set_default_config(self) -> None:
         pass
 
+    def get_init_symbols(self) -> list:
+        try:
+            if self.has_historical_config():
+                self.update_config_and_user_inputs_if_necessary()
+            return self.get_tentacle_config_traded_symbols(
+                self.trading_config, self.exchange_manager.exchange_personal_data.portfolio_manager.reference_market
+            )
+        except NotImplementedError:
+            return self.exchange_manager.exchange_config.traded_symbol_pairs
+
+
     """
     Strategy related methods
     """

{OctoBot-Trading-2.4.125 → OctoBot-Trading-2.4.127}/octobot_trading/modes/channel/abstract_mode_producer.py

@@ -455,20 +455,25 @@ class AbstractTradingModeProducer(modes_channel.ModeChannelProducer):
             self.logger.error(f"Initialization took more than {timeout} seconds")
         return False
 
-    async def _wait_for_bot_init(self, timeout, extra_topics: list=None) -> bool:
+    async def _wait_for_bot_init(self, timeout, extra_symbol_topics: list=None, extra_global_topics: list=None) -> bool:
         try:
-            topics = [
-                common_enums.InitializationEventExchangeTopics.BALANCE.value,
-                common_enums.InitializationEventExchangeTopics.ORDERS.value
-            ] + (extra_topics if extra_topics else [])
+            init_symbols = self.trading_mode.get_init_symbols()
+            symbol_topics = [common_enums.InitializationEventExchangeTopics.ORDERS.value] + (extra_symbol_topics or [])
             if self.trading_mode.REQUIRE_TRADES_HISTORY:
-                topics.append(common_enums.InitializationEventExchangeTopics.TRADES.value)
-            for topic in topics:
+                symbol_topics.append(common_enums.InitializationEventExchangeTopics.TRADES.value)
+            for symbol_topic in symbol_topics:
                 self.logger.debug(f"Trading mode [{self.exchange_manager.exchange_name}] start complete. "
-                                  f"Now waiting for {topic} full initialisation.")
-                await util.wait_for_topic_init(self.exchange_manager, timeout, topic)
+                                  f"1/2: Now waiting for {symbol_topic} (for {init_symbols}) full initialisation.")
+                await util.wait_for_topic_init(
+                    self.exchange_manager, timeout, symbol_topic, symbols=init_symbols
+                )
+            global_topics = [common_enums.InitializationEventExchangeTopics.BALANCE.value] + (extra_global_topics or [])
+            for global_topic in global_topics:
+                self.logger.debug(f"Trading mode [{self.exchange_manager.exchange_name}] start complete. "
+                                  f"2/2: Now waiting for {global_topics} full initialisation.")
+                await util.wait_for_topic_init(self.exchange_manager, timeout, global_topic)
             self.logger.debug(
-                f"Trading mode requirements init complete: {', '.join(t for t in topics)} initialisation completed."
+                f"Trading mode requirements init complete: {', '.join(t for t in symbol_topics)} initialisation completed."
             )
             return True
         except (asyncio.TimeoutError, concurrent.futures.TimeoutError):
@@ -507,14 +512,19 @@ class AbstractTradingModeProducer(modes_channel.ModeChannelProducer):
         # can be slow, call in a task if necessary
         if context.exchange_manager.is_future:
             if not self._is_ready_to_trade.is_set():
-                await util.wait_for_topic_init(self.exchange_manager, self.CONFIG_INIT_TIMEOUT,
-                                               common_enums.InitializationEventExchangeTopics.CONTRACTS.value)
+                await util.wait_for_topic_init(
+                    self.exchange_manager, self.CONFIG_INIT_TIMEOUT,
+                    common_enums.InitializationEventExchangeTopics.CONTRACTS.value,
+                    symbols=self.trading_mode.get_init_symbols()
+                )
             await script_keywords.set_leverage(context, await script_keywords.user_select_leverage(context))
 
     async def _wait_for_symbol_prices_and_profitability_init(self, timeout) -> bool:
         try:
-            await util.wait_for_topic_init(self.exchange_manager, timeout,
-                                           common_enums.InitializationEventExchangeTopics.PRICE.value)
+            await util.wait_for_topic_init(
+                self.exchange_manager, timeout, common_enums.InitializationEventExchangeTopics.PRICE.value,
+                symbols=self.trading_mode.get_init_symbols()
+            )
             await util.wait_for_topic_init(self.exchange_manager, timeout,
                                            common_enums.InitializationEventExchangeTopics.PROFITABILITY.value)
         except (asyncio.TimeoutError, concurrent.futures.TimeoutError):

{OctoBot-Trading-2.4.125 → OctoBot-Trading-2.4.127}/octobot_trading/personal_data/orders/decimal_order_adapter.py

@@ -212,11 +212,11 @@ def decimal_check_and_adapt_order_details_if_necessary(quantity, price, symbol_m
     valid_price = decimal_adapt_price(symbol_market, price, truncate)
 
     # case 1: try with data directly from exchange
-    if personal_data.is_valid(limit_amount, Ecmsc.LIMITS_AMOUNT_MIN.value):
+    if personal_data.is_valid(limit_amount, Ecmsc.LIMITS_AMOUNT_MIN.value, zero_valid=True):
         min_quantity = decimal.Decimal(str(limit_amount.get(Ecmsc.LIMITS_AMOUNT_MIN.value, math.nan)))
         max_quantity = None
         # not all symbol data have a max quantity
-        if personal_data.is_valid(limit_amount, Ecmsc.LIMITS_AMOUNT_MAX.value):
+        if personal_data.is_valid(limit_amount, Ecmsc.LIMITS_AMOUNT_MAX.value, zero_valid=False):
             max_quantity = decimal.Decimal(str(limit_amount.get(Ecmsc.LIMITS_AMOUNT_MAX.value, math.nan)))
 
         total_order_price = valid_quantity * valid_price
@@ -226,11 +226,11 @@ def decimal_check_and_adapt_order_details_if_necessary(quantity, price, symbol_m
             return []
 
         # case 1.1: use only quantity and cost
-        if personal_data.is_valid(limit_cost, Ecmsc.LIMITS_COST_MIN.value):
+        if personal_data.is_valid(limit_cost, Ecmsc.LIMITS_COST_MIN.value, zero_valid=True):
             min_cost = decimal.Decimal(str(limit_cost.get(Ecmsc.LIMITS_COST_MIN.value, math.nan)))
             max_cost = None
             # not all symbol data have a max cost
-            if personal_data.is_valid(limit_cost, Ecmsc.LIMITS_COST_MAX.value):
+            if personal_data.is_valid(limit_cost, Ecmsc.LIMITS_COST_MAX.value, zero_valid=False):
                 max_cost = decimal.Decimal(str(limit_cost.get(Ecmsc.LIMITS_COST_MAX.value, math.nan)))
 
             # check total_order_price not < min_cost
@@ -250,11 +250,11 @@ def decimal_check_and_adapt_order_details_if_necessary(quantity, price, symbol_m
 
         # case 1.2: use only quantity and price (if available)
         else:
-            if personal_data.is_valid(limit_price, Ecmsc.LIMITS_PRICE_MIN.value):
+            if personal_data.is_valid(limit_price, Ecmsc.LIMITS_PRICE_MIN.value, zero_valid=True):
                 min_price = decimal.Decimal(str(limit_price.get(Ecmsc.LIMITS_PRICE_MIN.value, math.nan)))
                 max_price = None
                 # not all symbol data have a max price
-                if personal_data.is_valid(limit_price, Ecmsc.LIMITS_PRICE_MAX.value):
+                if personal_data.is_valid(limit_price, Ecmsc.LIMITS_PRICE_MAX.value, zero_valid=False):
                     max_price = decimal.Decimal(str(limit_price.get(Ecmsc.LIMITS_PRICE_MAX.value, math.nan)))
 
                 if (max_price is not None and (valid_price > max_price)) or valid_price < min_price:

{OctoBot-Trading-2.4.125 → OctoBot-Trading-2.4.127}/octobot_trading/personal_data/orders/order_util.py

@@ -34,14 +34,15 @@ from octobot_trading.enums import ExchangeConstantsMarketStatusColumns as Ecmsc
 LOGGER_NAME = "order_util"
 
 
-def is_valid(element, key):
+def is_valid(element, key, zero_valid=False):
     """
     Checks is the element is valid with the market status fixer
     :param element:
     :param key:
+    :param zero_valid: if 0 should be considered a valid value
     :return:
     """
-    return key in element and exchange_market_status_fixer.is_ms_valid(element[key])
+    return key in element and exchange_market_status_fixer.is_ms_valid(element[key], zero_valid=zero_valid)
 
 
 def get_min_max_amounts(symbol_market, default_value=None):

{OctoBot-Trading-2.4.125 → OctoBot-Trading-2.4.127}/octobot_trading/personal_data/trades/trades_manager.py

@@ -196,7 +196,8 @@ class TradesManager(util.Initializable):
         commons_tree.EventProvider.instance().trigger_event(
             self.trader.exchange_manager.bot_id, commons_tree.get_exchange_path(
                 self.trader.exchange_manager.exchange_name,
-                commons_enums.InitializationEventExchangeTopics.TRADES.value
+                commons_enums.InitializationEventExchangeTopics.TRADES.value,
+                symbol=symbol
             )
         )
 

{OctoBot-Trading-2.4.125 → OctoBot-Trading-2.4.127}/octobot_trading/storage/candles_storage.py

@@ -47,8 +47,15 @@ class CandlesStorage(abstract_storage.AbstractStorage):
         await super().stop(**kwargs)
 
     async def _store_candles_when_available(self):
-        await util.wait_for_topic_init(self.exchange_manager, self._init_timeout,
-                                       commons_enums.InitializationEventExchangeTopics.CANDLES.value)
+        init_symbols = (
+            self.exchange_manager.trading_modes[0].get_init_symbols()
+            if self.exchange_manager.trading_modes
+            else self.exchange_manager.exchange_config.traded_symbol_pairs
+        )
+        await util.wait_for_topic_init(
+            self.exchange_manager, self._init_timeout, commons_enums.InitializationEventExchangeTopics.CANDLES.value,
+            symbols=init_symbols
+        )
         await self.store_candles()
 
     @abstract_storage.AbstractStorage.hard_reset_and_retry_if_necessary

{OctoBot-Trading-2.4.125 → OctoBot-Trading-2.4.127}/octobot_trading/util/initialization_util.py

@@ -13,17 +13,27 @@
 #
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library.
+import asyncio
+
 import octobot_commons.tree as commons_tree
 
 
-async def wait_for_topic_init(exchange_manager, timeout, topic, symbol=None, time_frame=None):
-    return await commons_tree.EventProvider.instance().wait_for_event(
-        exchange_manager.bot_id,
-        commons_tree.get_exchange_path(
-            exchange_manager.exchange_name,
-            topic,
-            symbol=symbol,
-            time_frame=time_frame
-        ),
-        timeout
-    )
+async def wait_for_topic_init(exchange_manager, timeout, topic, symbol=None, time_frame=None, symbols=None):
+    if symbols:
+        return await asyncio.gather(
+            *[
+                wait_for_topic_init(exchange_manager, timeout, topic, symbol=local_symbol, time_frame=None)
+                for local_symbol in symbols
+            ]
+        )
+    else:
+        return await commons_tree.EventProvider.instance().wait_for_event(
+            exchange_manager.bot_id,
+            commons_tree.get_exchange_path(
+                exchange_manager.exchange_name,
+                topic,
+                symbol=symbol,
+                time_frame=time_frame
+            ),
+            timeout
+        )

{OctoBot-Trading-2.4.125 → OctoBot-Trading-2.4.127}/tests/exchanges/util/test_exchange_market_status_fixer.py

@@ -63,7 +63,7 @@ class TestExchangeMarketStatusFixer:
             Ecmsc.LIMITS.value: self._get_limits(
                 0.002190990480628382, 21909.904806283797,
                 0.05, 10000.0,
-                0.0001095495240314191, 219099048.062838
+                0, 219099048.062838
             )
         }
 
@@ -77,7 +77,7 @@ class TestExchangeMarketStatusFixer:
             Ecmsc.LIMITS.value: self._get_limits(
                 0.002190990480628382, 21909.904806283797,
                 0.05, 10000.0,
-                0.0001095495240314191, 219099048.062838
+                0, 219099048.062838
             )
         }
 
@@ -92,7 +92,7 @@ class TestExchangeMarketStatusFixer:
             Ecmsc.LIMITS.value: self._get_limits(
                 641.0256410256403, 64102564102564.04,
                 1.5600000000000002e-09, 0.0015600000000000002,
-                9.999999999999991e-07, 99999999999.99991
+                0, 99999999999.99991
             )
         }
 
@@ -107,14 +107,14 @@ class TestExchangeMarketStatusFixer:
             Ecmsc.LIMITS.value: self._get_limits(
                 6.37795818470299, 63779581.84702988,
                 0.0015678999, 1567.8999000000001,
-                0.01, 99999999999.99997
+                0, 99999999999.99997
             )
         }
 
         current_price = 25.87257
         ms = {
             Ecmsc.PRECISION.value: self._get_precision(),
-            Ecmsc.LIMITS.value: self._get_limits(None, None, 0, 0, None, None)
+            Ecmsc.LIMITS.value: self._get_limits(None, None, 0, 0, 11, None)
         }
 
         assert ExchangeMarketStatusFixer(ms, price_example=current_price).market_status == {
@@ -122,7 +122,7 @@ class TestExchangeMarketStatusFixer:
             Ecmsc.LIMITS.value: self._get_limits(
                 0.3865097282566056, 3865097.2825660524,
                 0.02587257, current_price * 1000,
-                0.010000000000000007, 99999999999.99997
+                11, 99999999999.99997
             )
         }
 
@@ -137,7 +137,7 @@ class TestExchangeMarketStatusFixer:
             Ecmsc.LIMITS.value: self._get_limits(
                 0.04986163396574511, 498616.3396574511,
                 3, 3,
-                0.14958490189723533, 1495849.0189723533
+                0, 1495849.0189723533
             )
         }
 
@@ -271,6 +271,50 @@ class TestExchangeMarketStatusFixer:
                 9.999999999999991e-07, 99999999999.99991
             )
 
+            emsf = ExchangeMarketStatusFixer({
+                Ecmsc.LIMITS.value: self._get_limits(cost_min=1, cost_max=11000.33)
+            }, 0.000999)
+            emsf._fix_market_status_limits_with_price()
+            assert emsf.market_status[Ecmsc.LIMITS.value] == self._get_limits(
+                1.001001001001, 100100100100.09999,
+                9.99e-07, 0.9990000000000001,
+                1, 11000.33
+            )
+
+            emsf = ExchangeMarketStatusFixer({
+                Ecmsc.LIMITS.value: self._get_limits(
+                    amount_min=0.1, amount_max=10000,
+                    price_min=44, price_max=4444,
+                )
+            }, 52)
+            # cost min max computed using price & amount
+            emsf._fix_market_status_limits_with_price()
+            assert emsf.market_status[Ecmsc.LIMITS.value] == self._get_limits(
+                0.1, 10000,
+                44, 4444,
+                4.4, 44440000
+            )
+
+            # cost max ONLY computed using price & amount (missing min price)
+            emsf = ExchangeMarketStatusFixer({
+                Ecmsc.LIMITS.value: self._get_limits(
+                    amount_min=0.1, amount_max=10000,
+                    price_max=4444,
+                )
+            }, 52)
+            assert emsf.market_status[Ecmsc.LIMITS.value] == self._get_limits(
+                0.1, 10000,
+                0.052, 4444,
+                0, 44440000    # min cost impossible to compute (no exchange info)
+            )
+            # min cost inferred from price (2nd call: consider min price as 'from exchange')
+            emsf._fix_market_status_limits_with_price()
+            assert emsf.market_status[Ecmsc.LIMITS.value] == self._get_limits(
+                0.1, 10000,
+                0.052, 4444,
+                0.0052, 44440000
+            )
+
     # Precision
     def test_get_price_precision(self):
         if not os.getenv('CYTHON_IGNORE'):