OctoBot-Trading 2.4.99__tar.gz → 2.4.100__tar.gz

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/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.100] - 2024-08-21
+### Added
+- [TradingModes] allow starting bot without enabled trading mode
+- [Tests] add active markets count tests
+### Updated
+- [Exchanges] use classmethods for autofilled exchanges
+- [Portfolio] add time window in history select
+
 ## [2.4.99] - 2024-08-19
 ### Updated
 - [CCXT] updated to ccxt 4.3.85

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100/OctoBot_Trading.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: OctoBot-Trading
-Version: 2.4.99
+Version: 2.4.100
 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.99](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.100](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.99/OctoBot_Trading.egg-info → OctoBot-Trading-2.4.100}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: OctoBot-Trading
-Version: 2.4.99
+Version: 2.4.100
 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.99](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.100](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.99 → OctoBot-Trading-2.4.100}/README.md

@@ -1,4 +1,4 @@
-# OctoBot-Trading [2.4.99](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.100](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.99 → OctoBot-Trading-2.4.100}/octobot_trading/__init__.py

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

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/octobot_trading/api/exchange.py

@@ -138,9 +138,8 @@ def get_matrix_id_from_exchange_id(exchange_name: str, exchange_id: str) -> str:
 
 def get_all_exchange_ids_from_matrix_id(matrix_id) -> list:
     return [
-        exchange_configuration.id
-        for exchange_configuration in exchanges.Exchanges.instance().get_all_exchanges()
-        if exchange_configuration.matrix_id == matrix_id
+        get_exchange_manager_id(exchange_manager)
+        for exchange_manager in exchanges.Exchanges.instance().get_exchanges_managers_with_matrix_id(matrix_id)
     ]
 
 

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/octobot_trading/constants.py

@@ -69,14 +69,18 @@ ENABLE_EXCHANGE_HTTP_PROXY_FROM_ENV = os_util.parse_boolean_environment_var(
 ENABLE_CCXT_VERBOSE = os_util.parse_boolean_environment_var("ENABLE_CCXT_VERBOSE", "False")
 ENABLE_CCXT_RATE_LIMIT = os_util.parse_boolean_environment_var("ENABLE_CCXT_RATE_LIMIT", "True")
 THROTTLED_WS_UPDATES = float(os.getenv("THROTTLED_WS_UPDATES", "0.1"))  # avoid spamming CPU
-ENABLE_LIVE_CANDLES_STORAGE = os_util.parse_boolean_environment_var("ENABLE_LIVE_CANDLES_STORAGE", "False")
-ENABLE_HISTORICAL_ORDERS_UPDATES_STORAGE = os_util.parse_boolean_environment_var("ENABLE_HISTORICAL_ORDERS_UPDATES_STORAGE", "False")
 MAX_CANDLES_IN_RAM = int(os.getenv("MAX_CANDLES_IN_RAM", "3000"))    # max candles per CandlesManager
 STORAGE_ORIGIN_VALUE = "origin_value"
 DISPLAY_TIME_FRAME = commons_enums.TimeFrames.ONE_HOUR
 DEFAULT_SUBACCOUNT_ID = "default_subaccount_id"
 DEFAULT_ACCOUNT_ID = "default_account_id"
 
+# Storage
+ENABLE_LIVE_CANDLES_STORAGE = os_util.parse_boolean_environment_var("ENABLE_LIVE_CANDLES_STORAGE", "False")
+ENABLE_HISTORICAL_ORDERS_UPDATES_STORAGE = os_util.parse_boolean_environment_var("ENABLE_HISTORICAL_ORDERS_UPDATES_STORAGE", "False")
+ENABLE_SIMULATED_ORDERS_STORAGE = os_util.parse_boolean_environment_var("ENABLE_SIMULATED_ORDERS_STORAGE", "False")
+AUTH_UPDATE_DEBOUNCE_DURATION = float(os.getenv("AUTH_UPDATE_DEBOUNCE_DURATION", "10"))
+
 # Decimal default values (decimals are immutable, can be stored as constant)
 ZERO = decimal.Decimal(0)
 ONE = decimal.Decimal(1)

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/octobot_trading/exchanges/exchange_builder.py

@@ -102,8 +102,13 @@ class ExchangeBuilder:
             raise e
 
     def _register_trading_modes_requirements(self, trading_mode_class, tentacles_setup_config):
-        self.exchange_manager.is_trading = trading_mode_class.get_is_trading_on_exchange(self.exchange_name,
-                                                                                         tentacles_setup_config)
+        self.exchange_manager.is_trading = trading_mode_class.get_is_trading_on_exchange(
+            self.exchange_name, tentacles_setup_config
+        )
+        if not self.exchange_manager.is_trading:
+            self.logger.info(
+                f"{self.exchange_manager.exchange_name} exchange is configured not to apply any trading strategy."
+            )
         # take trading modes candles requirements into account if any
         self.config[commons_constants.CONFIG_TENTACLES_REQUIRED_CANDLES_COUNT] = max(
             self.config[commons_constants.CONFIG_TENTACLES_REQUIRED_CANDLES_COUNT],

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/octobot_trading/exchanges/exchanges.py

@@ -59,6 +59,18 @@ class Exchanges(singleton.Singleton):
     def get_exchanges_list(self, exchange_name) -> list:
         return list(self.exchanges[exchange_name].values())
 
+    def get_exchanges_managers_with_matrix_id(self, matrix_id: str) -> list:
+        return [
+            exchange_configuration.exchange_manager
+            for exchange_configuration in self.get_all_exchanges()
+            if exchange_configuration.matrix_id == matrix_id
+        ]
+
+    def get_exchanges_managers_with_same_matrix_id(self, exchange_manager) -> list:
+        return self.get_exchanges_managers_with_matrix_id(
+            self.get_exchange(exchange_manager.exchange_name, exchange_manager.id).matrix_id
+        )
+
     def del_exchange(self, exchange_name, exchange_manager_id, should_warn=True) -> None:
         try:
             self.exchanges[exchange_name].pop(exchange_manager_id, None)

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/octobot_trading/exchanges/types/rest_exchange.py

@@ -950,8 +950,8 @@ class RestExchange(abstract_exchange.AbstractExchange):
     ):
         raise NotImplementedError("fetch_exchange_config")
 
-    @staticmethod
-    def supported_autofill_exchanges(tentacle_config):
+    @classmethod
+    def supported_autofill_exchanges(cls, tentacle_config):
         raise NotImplementedError("supported_autofill_exchanges is not implemented")
 
     @classmethod

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/octobot_trading/modes/abstract_trading_mode.py

@@ -447,9 +447,9 @@ class AbstractTradingMode(abstract_tentacle.AbstractTentacle):
     """
 
     @classmethod
-    def get_required_strategies_names_and_count(cls,
-                                                tentacles_config: tm_configuration.TentaclesSetupConfiguration,
-                                                trading_mode_config=None):
+    def get_required_strategies_names_and_count(
+        cls, tentacles_config: tm_configuration.TentaclesSetupConfiguration, trading_mode_config=None
+    ):
         config = trading_mode_config or tentacles_manager_api.get_tentacle_config(tentacles_config, cls)
         if constants.TRADING_MODE_REQUIRED_STRATEGIES in config:
             return config[constants.TRADING_MODE_REQUIRED_STRATEGIES], cls.get_required_strategies_count(config)

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/octobot_trading/modes/mode_config.py

@@ -47,12 +47,14 @@ def get_activated_trading_mode(tentacles_setup_config):
 
                 if trading_mode_class is not None:
                     return trading_mode_class
-        except ModuleNotFoundError as e:
-            logging.get_logger("get_activated_trading_mode").error(f"Error when loading "
-                                                                   f"the activated trading mode: {e}")
+        except ModuleNotFoundError as err:
+            logging.get_logger("get_activated_trading_mode").error(
+                f"Error when loading the activated trading mode: {err}"
+            )
 
-    raise errors.ConfigTradingError(f"Please ensure your tentacles configuration file is valid and "
-                                    f"at least one trading mode is activated")
+    raise errors.ConfigTradingError(
+        "Please ensure your tentacles configuration file is valid and that a trading mode is activated"
+    )
 
 
 def should_emit_trading_signals_user_input(trading_mode, inputs: dict):

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/octobot_trading/octobot_channel_consumer.py

@@ -20,9 +20,11 @@ import octobot_commons.channels_name as channels_name
 import octobot_commons.logging as logging
 import octobot_commons.enums as enums
 import octobot_commons.constants as commons_constants
+import octobot_commons.errors as commons_errors
 
 import octobot_trading.errors as errors
 import octobot_trading.exchanges as exchanges
+import octobot_trading.modes as modes
 import octobot_trading.util as util
 
 OCTOBOT_CHANNEL_TRADING_CONSUMER_LOGGER_TAG = "OctoBotChannelTradingConsumer"
@@ -70,6 +72,14 @@ async def _handle_creation(bot_id, action, data):
                 .has_matrix(data[OctoBotChannelTradingDataKeys.MATRIX_ID.value]) \
                 .use_tentacles_setup_config(data[OctoBotChannelTradingDataKeys.TENTACLES_SETUP_CONFIG.value]) \
                 .set_bot_id(bot_id)
+            try:
+                modes.get_activated_trading_mode(data[OctoBotChannelTradingDataKeys.TENTACLES_SETUP_CONFIG.value])
+            except commons_errors.ConfigTradingError:
+                logging.get_logger(OCTOBOT_CHANNEL_TRADING_CONSUMER_LOGGER_TAG).error(
+                    f"No configured trading mode. in order to trade, selected a profile with a trading mode."
+                )
+                # do not raise on missing trading mode
+                exchange_builder.disable_trading_mode()
             _set_exchange_type_details(exchange_builder, config, data[OctoBotChannelTradingDataKeys.BACKTESTING.value])
             await exchange_builder.build()
             await channel_instances.get_chan_at_id(

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/octobot_trading/personal_data/portfolios/history/historical_portfolio_value_manager.py

@@ -157,10 +157,13 @@ class HistoricalPortfolioValueManager(util.Initializable):
         """
         to_timestamp = to_timestamp or self.portfolio_manager.exchange_manager.exchange.get_exchange_current_time()
         time_frame_seconds = commons_enums.TimeFramesMinutes[time_frame] * commons_constants.MINUTE_TO_SECONDS
+        sorted_available_timestamps = list(self.historical_portfolio_value)
         relevant_historical_values = [
             value
             for timestamp, value in self.historical_portfolio_value.items()
-            if self._is_historical_timestamp_relevant(timestamp, time_frame_seconds, from_timestamp, to_timestamp)
+            if self._is_historical_timestamp_relevant(
+                timestamp, time_frame_seconds, from_timestamp, to_timestamp, sorted_available_timestamps
+            )
         ]
         historical_values = {}
         for historical_value in relevant_historical_values:
@@ -252,15 +255,34 @@ class HistoricalPortfolioValueManager(util.Initializable):
                 if currency not in self.historical_starting_portfolio_values:
                     self.historical_starting_portfolio_values[currency] = value.get(currency)
 
-    def _is_historical_timestamp_relevant(self, timestamp, time_frame_seconds, from_timestamp, to_timestamp):
+    def _is_historical_timestamp_relevant(
+        self, timestamp, time_frame_seconds, from_timestamp, to_timestamp, sorted_available_timestamps: list
+    ):
         from_timestamp = from_timestamp or 0
         to_timestamp = to_timestamp or time.time()
-        return self._is_timestamp_relevant(timestamp, time_frame_seconds) and \
+        return self._is_timestamp_relevant(timestamp, time_frame_seconds, sorted_available_timestamps) and \
            from_timestamp <= timestamp <= to_timestamp
 
     @staticmethod
-    def _is_timestamp_relevant(timestamp, time_frame_seconds):
-        return timestamp % time_frame_seconds == 0
+    def _is_timestamp_relevant(timestamp, time_frame_seconds, sorted_available_timestamps: list):
+        if timestamp % time_frame_seconds == 0:
+            # timestamp is expected at this time
+            return True
+        else:
+            # timestamp is relevant only if there is no other available timestamp within the given timeframe range
+            current_timestamp_index = sorted_available_timestamps.index(timestamp)
+            allowed_delta = time_frame_seconds / 2
+            previous_timestamp = (
+                sorted_available_timestamps[current_timestamp_index - 1]
+                if current_timestamp_index > 0
+                else 0
+            )
+            next_timestamp = (
+                sorted_available_timestamps[current_timestamp_index + 1]
+                if current_timestamp_index < len(sorted_available_timestamps) - 1
+                else (timestamp + allowed_delta)
+            )
+            return previous_timestamp + allowed_delta <= timestamp <= next_timestamp - allowed_delta
 
     @staticmethod
     def convert_to_historical_timestamp(timestamp, time_frame):

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/octobot_trading/storage/abstract_storage.py

@@ -31,7 +31,6 @@ class AbstractStorage:
     LIVE_CHANNEL = None
     IS_HISTORICAL = True
     HISTORY_TABLE = None
-    AUTH_UPDATE_DEBOUNCE_DURATION = 10
     FLUSH_DEBOUNCE_DURATION = 5   # avoid disc spam on multiple quick live updated
 
     def __init__(self, exchange_manager, plot_settings: commons_display.PlotSettings,
@@ -123,7 +122,7 @@ class AbstractStorage:
 
     async def _waiting_update_auth_data(self, reset):
         try:
-            await asyncio.sleep(self.AUTH_UPDATE_DEBOUNCE_DURATION)
+            await asyncio.sleep(trading_constants.AUTH_UPDATE_DEBOUNCE_DURATION)
             await self._update_auth_data(reset)
         except Exception as err:
             logging.get_logger(self.__class__.__name__).exception(err, True, f"Error when updating auth data: {err}")

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/octobot_trading/storage/orders_storage.py

@@ -27,6 +27,7 @@ import octobot_trading.enums as enums
 import octobot_trading.constants as constants
 import octobot_trading.storage.abstract_storage as abstract_storage
 import octobot_trading.storage.util as storage_util
+import octobot_trading.exchanges as exchanges
 
 
 class OrdersStorage(abstract_storage.AbstractStorage):
@@ -36,13 +37,16 @@ class OrdersStorage(abstract_storage.AbstractStorage):
     ENABLE_HISTORICAL_ORDER_UPDATES_STORAGE = constants.ENABLE_HISTORICAL_ORDERS_UPDATES_STORAGE
 
     def __init__(self, exchange_manager, use_live_consumer_in_backtesting=None, is_historical=None):
-        super().__init__(exchange_manager, plot_settings=None,
-                         use_live_consumer_in_backtesting=use_live_consumer_in_backtesting, is_historical=is_historical)
+        super().__init__(
+            exchange_manager, plot_settings=None,
+            use_live_consumer_in_backtesting=use_live_consumer_in_backtesting, is_historical=is_historical
+        )
         self.startup_orders = {}
 
     def should_store_data(self):
-        return not self.exchange_manager.is_trader_simulated \
-            and not self.exchange_manager.is_backtesting
+        return (
+            constants.ENABLE_SIMULATED_ORDERS_STORAGE or not self.exchange_manager.is_trader_simulated
+        ) and not self.exchange_manager.is_backtesting
 
     async def on_start(self):
         await self._load_startup_orders()
@@ -86,13 +90,19 @@ class OrdersStorage(abstract_storage.AbstractStorage):
 
     async def _update_auth_data(self, _):
         authenticator = authentication.Authenticator.instance()
-        snapshot = [
-            _format_order(order, self.exchange_manager)
-            for order in self.exchange_manager.exchange_personal_data.orders_manager.get_open_orders()
-        ]
+
+        orders_by_exchange = {
+            exchange_manager.exchange_name: [
+                _format_order(order, exchange_manager)
+                for order in exchange_manager.exchange_personal_data.orders_manager.get_open_orders()
+            ]
+            for exchange_manager in exchanges.Exchanges.instance().get_exchanges_managers_with_same_matrix_id(
+                self.exchange_manager
+            )
+        }
         if authenticator.is_initialized():
             # also update when history is empty to reset trade history
-            await authenticator.update_orders(snapshot, self.exchange_manager.exchange_name)
+            await authenticator.update_orders(orders_by_exchange)
 
     async def _store_history(self):
         await self._update_history()

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/octobot_trading/storage/portfolio_storage.py

@@ -17,10 +17,12 @@ import octobot_commons.enums as commons_enums
 import octobot_commons.authentication as authentication
 import octobot_commons.databases as commons_databases
 import octobot_commons.tree as commons_tree
+import octobot_commons.constants as commons_constants
 
 import octobot_trading.storage.abstract_storage as abstract_storage
 import octobot_trading.storage.util as storage_util
 import octobot_trading.personal_data.portfolios.history as portfolio_history
+import octobot_trading.exchanges as exchanges
 
 
 class PortfolioStorage(abstract_storage.AbstractStorage):
@@ -57,19 +59,22 @@ class PortfolioStorage(abstract_storage.AbstractStorage):
         await self.trigger_debounced_update_auth_data(reset)
 
     async def _update_auth_data(self, reset):
-        hist_portfolio_values_manager = self.exchange_manager.exchange_personal_data. \
-            portfolio_manager.historical_portfolio_value_manager
         authenticator = authentication.Authenticator.instance()
-        full_history = hist_portfolio_values_manager.get_dict_historical_values()
-        history = [
-            history_val
-            for history_val in full_history
-            if history_val[portfolio_history.HistoricalAssetValue.TIMESTAMP_KEY] in self._to_update_auth_data_ids_buffer
-        ]
-        if full_history and authenticator.is_initialized():
-            initializing_prices = hist_portfolio_values_manager.portfolio_manager.portfolio_value_holder.\
-                value_converter.initializing_symbol_prices_pairs
-            if initializing_prices:
+        if not authenticator.is_initialized():
+            return
+        current_value = 0
+        initial_value_by_timestamp = {}
+        reference_market = None
+        ending_portfolio = {}
+        price_by_asset = {}
+        historical_value_by_timestamp = {}
+        for exchange_manager in exchanges.Exchanges.instance().get_exchanges_managers_with_same_matrix_id(
+            self.exchange_manager
+        ):
+            hist_portfolio_values_manager = exchange_manager.exchange_personal_data. \
+                portfolio_manager.historical_portfolio_value_manager
+            if initializing_prices := hist_portfolio_values_manager.portfolio_manager.portfolio_value_holder.\
+                value_converter.initializing_symbol_prices_pairs:
                 for symbol in initializing_prices:
                     await commons_tree.EventProvider.instance().wait_for_event(
                         self.exchange_manager.bot_id,
@@ -80,20 +85,54 @@ class PortfolioStorage(abstract_storage.AbstractStorage):
                         ),
                         self.PRICE_INIT_TIMEOUT
                     )
-            # skip portfolio history on simulated trading
-            histories = {} if self.exchange_manager.is_trader_simulated else {
-                history_val[portfolio_history.HistoricalAssetValue.TIMESTAMP_KEY]:
-                    history_val[portfolio_history.HistoricalAssetValue.VALUES_KEY]
-                for history_val in history
-            }
+            full_history = hist_portfolio_values_manager.get_dict_historical_values()
+            if not (full_history and hist_portfolio_values_manager.ending_portfolio):
+                continue
+            reference_market = hist_portfolio_values_manager.portfolio_manager.reference_market
+            price_by_asset.update(
+                hist_portfolio_values_manager.portfolio_manager.portfolio_value_holder.current_crypto_currencies_values
+            )
+            if hist_portfolio_values_manager.ending_portfolio:
+                for asset, value in hist_portfolio_values_manager.ending_portfolio.items():
+                    if asset not in ending_portfolio:
+                        ending_portfolio[asset] = {
+                            commons_constants.PORTFOLIO_AVAILABLE: 0,
+                            commons_constants.PORTFOLIO_TOTAL: 0
+                        }
+                    ending_portfolio[asset][commons_constants.PORTFOLIO_AVAILABLE] += \
+                        value[commons_constants.PORTFOLIO_AVAILABLE]
+                    ending_portfolio[asset][commons_constants.PORTFOLIO_TOTAL] += \
+                        value[commons_constants.PORTFOLIO_TOTAL]
+            current_value += full_history[-1][portfolio_history.HistoricalAssetValue.VALUES_KEY].get(reference_market, 0)
+            min_ts = full_history[0][portfolio_history.HistoricalAssetValue.TIMESTAMP_KEY]
+            initial_value_by_timestamp[min_ts] = initial_value_by_timestamp.get(min_ts, 0) + \
+                full_history[0][portfolio_history.HistoricalAssetValue.VALUES_KEY].get(reference_market, 0)
+            history = [
+                history_val
+                for history_val in hist_portfolio_values_manager.get_dict_historical_values()
+                if history_val[portfolio_history.HistoricalAssetValue.TIMESTAMP_KEY] in self._to_update_auth_data_ids_buffer
+            ]
+            if not self.exchange_manager.is_trader_simulated:
+                # skip portfolio history on simulated trading
+                for history_val in history:
+                    ts = history_val[portfolio_history.HistoricalAssetValue.TIMESTAMP_KEY]
+                    value = history_val[portfolio_history.HistoricalAssetValue.VALUES_KEY]
+                    if ts in historical_value_by_timestamp:
+                        historical_value_by_timestamp[ts] += value
+                    else:
+                        historical_value_by_timestamp[ts] = value
+
+        if current_value:
+            # only consider the initial value of the min timestamp
+            initial_value = initial_value_by_timestamp[min(initial_value_by_timestamp)]
             await authenticator.update_portfolio(
-                full_history[-1][portfolio_history.HistoricalAssetValue.VALUES_KEY],
-                full_history[0][portfolio_history.HistoricalAssetValue.VALUES_KEY],
-                float(hist_portfolio_values_manager.portfolio_manager.portfolio_profitability.profitability_percent),
-                hist_portfolio_values_manager.portfolio_manager.reference_market,
-                hist_portfolio_values_manager.ending_portfolio,
-                histories,
-                hist_portfolio_values_manager.portfolio_manager.portfolio_value_holder.current_crypto_currencies_values,
+                {reference_market: current_value},
+                {reference_market: initial_value},
+                (100 * current_value / initial_value) - 100,
+                reference_market,
+                ending_portfolio,
+                historical_value_by_timestamp,
+                price_by_asset,
                 reset
             )
             self._to_update_auth_data_ids_buffer.clear()

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/requirements.txt

@@ -8,7 +8,6 @@ OctoBot-Tentacles-Manager>=2.9, <2.10
 trading-backend>=1.2.7
 
 # Exchange connection requirements
-# issue from 96, need ccxt==4.2.99
 ccxt==4.3.85 # always ensure real exchanges tests (in tests_additional and authenticated exchange tests) are passing before changing the ccxt version
 
 cryptography # Never specify a version (managed by https://github.com/Drakkar-Software/OctoBot-PyPi-Linux-Deployer)

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/tests/exchanges/__init__.py

@@ -101,8 +101,8 @@ class MockedAutoFillRestExchange(MockedRestExchange):
     ):
         pass
 
-    @staticmethod
-    def supported_autofill_exchanges(tentacle_config):
+    @classmethod
+    def supported_autofill_exchanges(cls, tentacle_config):
         return MockedAutoFillRestExchange._SUPPORTED_EXCHANGE_MOCK
 
     @classmethod

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/tests/personal_data/portfolios/history/test_historical_portfolio_value_manager.py

@@ -521,7 +521,10 @@ async def test_get_historical_values(historical_portfolio_value_manager):
         time_manager.current_timestamp = late_timestamp
     await historical_portfolio_value_manager.on_new_value(late_timestamp, late_values, save_changes=False)
     assert historical_portfolio_value_manager.get_historical_values("USD", commons_enums.TimeFrames.ONE_DAY) == \
-        {friday_timestamp: 3010, sunday_timestamp: 3, today_timestamp: 54}
+        {
+            friday_timestamp: 3010, sunday_timestamp: 3, today_timestamp: 54,
+            late_timestamp: 88  # window select include latest value
+        }
     historical_portfolio_value_manager.logger.debug.assert_called_once()
     historical_portfolio_value_manager.logger.debug.reset_mock()
     assert historical_portfolio_value_manager.get_historical_values("BTC", commons_enums.TimeFrames.ONE_HOUR) == \
@@ -529,6 +532,14 @@ async def test_get_historical_values(historical_portfolio_value_manager):
          late_timestamp: 77}
     historical_portfolio_value_manager.logger.debug.assert_called_once()
     historical_portfolio_value_manager.logger.debug.reset_mock()
+    # with ask timeframe that doesn't round with stored values: adapt select window
+    assert historical_portfolio_value_manager.get_historical_values("BTC", commons_enums.TimeFrames.FOUR_HOURS) == \
+        {
+            friday_timestamp: 1.1, saturday_timestamp: 1.3, today_timestamp: 11, today_hour_timestamp: 11,
+            late_timestamp: 77
+        }
+    historical_portfolio_value_manager.logger.debug.assert_called_once()
+    historical_portfolio_value_manager.logger.debug.reset_mock()
 
     # add 1h missing value to convertable pairs
     convertable_pair = "BTC/USD"

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/tests_additional/real_exchanges/real_exchange_tester.py

@@ -151,6 +151,19 @@ class RealExchangeTester:
         async with self.get_exchange_manager() as exchange_manager:
             return exchange_manager.exchange.time_frames
 
+    async def test_active_symbols(self):
+        raise NotImplementedError("test_active_symbols is not implemented")
+
+    async def inner_test_active_symbols(self, expected_active_symbols_count: int, expected_total_symbols_count: int):
+        async with self.get_exchange_manager() as exchange_manager:
+            # ensure active symbols are correctly parsed by ccxt
+            active_symbols = exchange_manager.exchange.connector.get_client_symbols(active_only=True)
+            assert expected_active_symbols_count <= len(active_symbols) <= expected_active_symbols_count * 1.5, \
+                f"{len(active_symbols)=}, {expected_active_symbols_count=}"
+            all_symbols = exchange_manager.exchange.connector.get_client_symbols(active_only=False)
+            assert expected_total_symbols_count <= len(all_symbols) <= expected_total_symbols_count * 1.5, \
+                f"{len(all_symbols)=}, {expected_total_symbols_count=}"
+
     async def get_market_statuses(self):
         # return 2 different market status with different traded pairs to reduce possible
         # side effects using only one pair.

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/tests_additional/real_exchanges/test_ascendex.py

@@ -50,6 +50,9 @@ class TestAscendExRealExchangeTester(RealExchangeTester):
             TimeFrames.ONE_MONTH.value
         ))
 
+    async def test_active_symbols(self):
+        await self.inner_test_active_symbols(500, 1000)
+
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
             self.ensure_required_market_status_values(market_status)

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/tests_additional/real_exchanges/test_binance.py

@@ -54,6 +54,10 @@ class TestBinanceRealExchangeTester(RealExchangeTester):
             TimeFrames.ONE_MONTH.value
         ))
 
+    async def test_active_symbols(self):
+        # binanceus numbers
+        await self.inner_test_active_symbols(150, 500)
+
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
             self.ensure_required_market_status_values(market_status)

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/tests_additional/real_exchanges/test_binance_futures.py

@@ -57,6 +57,9 @@ class TestBinanceFuturesRealExchangeTester(RealFuturesExchangeTester):
             TimeFrames.ONE_MONTH.value
         ))
 
+    async def test_active_symbols(self):
+        await self.inner_test_active_symbols(1500, 3000)
+
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
             self.ensure_required_market_status_values(market_status)

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/tests_additional/real_exchanges/test_bingx.py

@@ -54,6 +54,9 @@ class TestBingxRealExchangeTester(RealExchangeTester):
             TimeFrames.ONE_MONTH.value
         ))
 
+    async def test_active_symbols(self):
+        await self.inner_test_active_symbols(1000, 1200)
+
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
             # on Bingx, precision is a decimal instead of a number of digits

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/tests_additional/real_exchanges/test_bitfinex.py

@@ -53,6 +53,9 @@ class TestBitfinexRealExchangeTester(RealExchangeTester):
             TimeFrames.ONE_MONTH.value
         ))
 
+    async def test_active_symbols(self):
+        await self.inner_test_active_symbols(500, 500)
+
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
             self.ensure_required_market_status_values(market_status)

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/tests_additional/real_exchanges/test_bitget.py

@@ -55,6 +55,9 @@ class TestBitgetRealExchangeTester(RealExchangeTester):
             # TimeFrames.ONE_MONTH.value
         ))
 
+    async def test_active_symbols(self):
+        await self.inner_test_active_symbols(1000, 1200)
+
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
             self.ensure_required_market_status_values(market_status)

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/tests_additional/real_exchanges/test_bithumb.py

@@ -48,6 +48,9 @@ class TestBithumbRealExchangeTester(RealExchangeTester):
             TimeFrames.ONE_DAY.value,
         ))
 
+    async def test_active_symbols(self):
+        await self.inner_test_active_symbols(300, 300)
+
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
             self.ensure_required_market_status_values(market_status)

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/tests_additional/real_exchanges/test_bitmart.py

@@ -50,6 +50,9 @@ class TestBitMartRealExchangeTester(RealExchangeTester):
             TimeFrames.ONE_MONTH.value,
         ))
 
+    async def test_active_symbols(self):
+        await self.inner_test_active_symbols(1700, 1700)
+
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
             self.ensure_required_market_status_values(market_status)

{OctoBot-Trading-2.4.99 → OctoBot-Trading-2.4.100}/tests_additional/real_exchanges/test_bitso.py

@@ -47,6 +47,9 @@ class TestBitsoRealExchangeTester(RealExchangeTester):
             TimeFrames.ONE_WEEK.value,
         ))
 
+    async def test_active_symbols(self):
+        await self.inner_test_active_symbols(90, 90)
+
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
             self.ensure_required_market_status_values(market_status)