OctoBot-Trading 2.4.97__tar.gz → 2.4.98__tar.gz

{OctoBot-Trading-2.4.97 → OctoBot-Trading-2.4.98}/CHANGELOG.md

@@ -4,6 +4,11 @@ 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.98] - 2024-08-16
+### Added
+- [Exchanges] exchange_config_by_exchange in init
+- [Trades] option to ignore cancelled orders  
+
 ## [2.4.97] - 2024-08-14
 ### Added
 - [Exchanges] cancel_all_orders

{OctoBot-Trading-2.4.97 → OctoBot-Trading-2.4.98/OctoBot_Trading.egg-info}/PKG-INFO

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

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

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

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

{OctoBot-Trading-2.4.97 → OctoBot-Trading-2.4.98}/octobot_trading/exchanges/abstract_exchange.py

@@ -72,7 +72,7 @@ class AbstractExchange(tentacles_management.AbstractTentacle):
     }
     ACCOUNTS = {}
 
-    def __init__(self, config, exchange_manager):
+    def __init__(self, config, exchange_manager, exchange_config_by_exchange: typing.Optional[dict[str, dict]]):
         super().__init__()
         self.config = config
         self.exchange_manager = exchange_manager
@@ -97,6 +97,8 @@ class AbstractExchange(tentacles_management.AbstractTentacle):
 
         self._creating_exchange_order_descriptions = set()
 
+        if exchange_config_by_exchange and self.get_name() in exchange_config_by_exchange:
+            self.tentacle_config = exchange_config_by_exchange[self.get_name()]
         if self.exchange_manager.tentacles_setup_config is not None:
             self.load_user_inputs_from_class(self.exchange_manager.tentacles_setup_config, self.tentacle_config)
 

{OctoBot-Trading-2.4.97 → OctoBot-Trading-2.4.98}/octobot_trading/exchanges/config/exchange_config_data.py

@@ -68,6 +68,9 @@ class ExchangeConfig(util.Initializable):
         # periodic updaters that should always be started for this configuration
         self.forced_updater_channels = set()
 
+        # When False, cancelled orders won't be saved in trades history
+        self.is_saving_cancelled_orders_as_trade = True
+
         self.backtesting_exchange_config = None
 
     async def initialize_impl(self):
@@ -150,6 +153,9 @@ class ExchangeConfig(util.Initializable):
     def add_forced_updater_channels(self, channel: set[str]):
         self.forced_updater_channels.update(channel)
 
+    def set_is_saving_cancelled_orders_as_trade(self, value: bool):
+        self.is_saving_cancelled_orders_as_trade = value
+
     async def add_watched_symbols(self, symbols):
         new_valid_symbols = [
             symbol

{OctoBot-Trading-2.4.97 → OctoBot-Trading-2.4.98}/octobot_trading/exchanges/connectors/ccxt/ccxt_connector.py

@@ -50,7 +50,7 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
     def __init__(
         self, config, exchange_manager, adapter_class=None, additional_config=None, rest_name=None, force_auth=False
     ):
-        super().__init__(config, exchange_manager)
+        super().__init__(config, exchange_manager, None)
         self.client = None
         self.exchange_type = None
         self.adapter = self.get_adapter_class(adapter_class)(self)

{OctoBot-Trading-2.4.97 → OctoBot-Trading-2.4.98}/octobot_trading/exchanges/connectors/simulator/exchange_simulator_connector.py

@@ -35,7 +35,7 @@ import octobot_trading.exchanges.util as util
 
 class ExchangeSimulatorConnector(abstract_exchange.AbstractExchange):
     def __init__(self, config, exchange_manager, backtesting, adapter_class=None):
-        super().__init__(config, exchange_manager)
+        super().__init__(config, exchange_manager, None)
         self.backtesting = backtesting
         self.allowed_time_lag = constants.DEFAULT_BACKTESTING_TIME_LAG
         self.adapter = self.get_adapter_class(adapter_class)(self)

{OctoBot-Trading-2.4.97 → OctoBot-Trading-2.4.98}/octobot_trading/exchanges/exchange_builder.py

@@ -37,6 +37,7 @@ class ExchangeBuilder:
         self._is_using_trading_modes: bool = True
         self._matrix_id: str = None
         self.trading_config_by_trading_mode: dict = None
+        self.exchange_config_by_exchange: dict = None
         self.auto_start_trading_modes: bool = True
 
     async def build(self):
@@ -61,10 +62,12 @@ class ExchangeBuilder:
             if self._is_using_trading_modes:
                 trading_mode_class = modes.get_activated_trading_mode(self.exchange_manager.tentacles_setup_config)
                 # handle exchange related requirements if the activated trading mode has any
-                self._register_trading_modes_requirements(trading_mode_class, self.exchange_manager.tentacles_setup_config)
+                self._register_trading_modes_requirements(
+                    trading_mode_class, self.exchange_manager.tentacles_setup_config
+                )
 
             self._ensure_exchange_compatibility()
-            await self.exchange_manager.initialize()
+            await self.exchange_manager.initialize(exchange_config_by_exchange=self.exchange_config_by_exchange)
             # add exchange to be able to use it
             exchanges.Exchanges.instance().add_exchange(self.exchange_manager, self._matrix_id)
 
@@ -110,6 +113,9 @@ class ExchangeBuilder:
         self.exchange_manager.exchange_config.add_forced_updater_channels(
             trading_mode_class.get_forced_updater_channels()
         )
+        self.exchange_manager.exchange_config.set_is_saving_cancelled_orders_as_trade(
+            not trading_mode_class.is_ignoring_cancelled_orders_trades()
+        )
 
     async def _build_trading_modes_if_required(self, trading_mode_class):
         if self._is_using_trading_modes:
@@ -270,6 +276,10 @@ class ExchangeBuilder:
         self.trading_config_by_trading_mode = trading_config_by_trading_mode
         return self
 
+    def use_exchange_config_by_exchange(self, exchange_config_by_exchange: typing.Optional[dict[str, dict]]):
+        self.exchange_config_by_exchange = exchange_config_by_exchange
+        return self
+
     def set_auto_start_trading_modes(self, auto_start_trading_modes):
         self.auto_start_trading_modes = auto_start_trading_modes
         return self

{OctoBot-Trading-2.4.97 → OctoBot-Trading-2.4.98}/octobot_trading/exchanges/exchange_factory.py

@@ -14,6 +14,7 @@
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library.
 import asyncio
+import typing
 
 import trading_backend
 
@@ -22,7 +23,7 @@ import octobot_trading.errors as errors
 import octobot_trading.exchanges as exchanges
 
 
-async def create_exchanges(exchange_manager):
+async def create_exchanges(exchange_manager, exchange_config_by_exchange: typing.Optional[dict[str, dict]]):
     if exchange_manager.is_sandboxed and not exchange_manager.exchange_only:
         exchange_manager.logger.info(f"Using sandbox exchange for {exchange_manager.exchange_name}")
 
@@ -32,7 +33,7 @@ async def create_exchanges(exchange_manager):
         exchange_manager.load_constants()
     else:
         # real : create a rest or websocket exchange instance
-        await create_real_exchange(exchange_manager)
+        await create_real_exchange(exchange_manager, exchange_config_by_exchange)
         exchange_manager.load_constants()
         await initialize_real_exchange(exchange_manager)
 
@@ -47,12 +48,13 @@ async def create_exchanges(exchange_manager):
     exchange_manager.is_ready = True
 
 
-async def create_real_exchange(exchange_manager) -> None:
+async def create_real_exchange(exchange_manager, exchange_config_by_exchange: typing.Optional[dict[str, dict]]) -> None:
     """
     Create and initialize real REST exchange
     :param exchange_manager: the related exchange manager
+    :param exchange_config_by_exchange: optional exchange configurations
     """
-    await _create_rest_exchange(exchange_manager)
+    await _create_rest_exchange(exchange_manager, exchange_config_by_exchange)
     try:
         await exchange_manager.exchange.initialize()
         _create_exchange_backend(exchange_manager)
@@ -62,7 +64,7 @@ async def create_real_exchange(exchange_manager) -> None:
     except errors.AuthenticationError:
         exchange_manager.logger.error("Authentication error, retrying without authentication...")
         exchange_manager.without_auth = True
-        await create_real_exchange(exchange_manager)
+        await create_real_exchange(exchange_manager, exchange_config_by_exchange)
         return
 
 
@@ -112,12 +114,14 @@ async def _is_supporting_octobot() -> bool:
     return False
 
 
-async def _create_rest_exchange(exchange_manager) -> None:
+async def _create_rest_exchange(
+    exchange_manager, exchange_config_by_exchange: typing.Optional[dict[str, dict]]
+) -> None:
     """
     create REST based on ccxt exchange
     :param exchange_manager: the related exchange manager
     """
-    await _search_and_create_rest_exchange(exchange_manager)
+    await _search_and_create_rest_exchange(exchange_manager, exchange_config_by_exchange)
 
     if not exchange_manager.exchange:
         raise Exception(f"Can't create an exchange instance that match the exchange configuration ({exchange_manager})")
@@ -139,16 +143,23 @@ async def init_simulated_exchange(exchange_manager):
     await exchange_manager.exchange.create_backtesting_exchange_producers()
 
 
-async def _search_and_create_rest_exchange(exchange_manager) -> None:
+async def _search_and_create_rest_exchange(
+    exchange_manager, exchange_config_by_exchange: typing.Optional[dict[str, dict]]
+) -> None:
     """
     Create a rest exchange if a RestExchange matching class is found
     :param exchange_manager: the related exchange manager
     """
-    rest_exchange_class = exchanges.get_rest_exchange_class(exchange_manager.exchange_name,
-                                                            exchange_manager.tentacles_setup_config)
+    rest_exchange_class = exchanges.get_rest_exchange_class(
+        exchange_manager.exchange_name, exchange_manager.tentacles_setup_config, exchange_config_by_exchange
+    )
     if rest_exchange_class:
-        exchange_manager.exchange = rest_exchange_class(config=exchange_manager.config,
-                                                        exchange_manager=exchange_manager)
+        if rest_exchange_class.HAS_FETCHED_DETAILS:
+            await rest_exchange_class.fetch_exchange_config(exchange_config_by_exchange, exchange_manager)
+        exchange_manager.exchange = rest_exchange_class(
+            config=exchange_manager.config, exchange_manager=exchange_manager,
+            exchange_config_by_exchange=exchange_config_by_exchange
+        )
 
 
 def _initialize_simulator_time_frames(exchange_manager):

{OctoBot-Trading-2.4.97 → OctoBot-Trading-2.4.98}/octobot_trading/exchanges/exchange_manager.py

@@ -85,8 +85,8 @@ class ExchangeManager(util.Initializable):
 
         self.debug_info = {}
 
-    async def initialize_impl(self):
-        await exchanges.create_exchanges(self)
+    async def initialize_impl(self, exchange_config_by_exchange: typing.Optional[dict[str, dict]]):
+        await exchanges.create_exchanges(self, exchange_config_by_exchange)
         if self.is_storage_enabled():
             await self.storage_manager.initialize()
 

{OctoBot-Trading-2.4.97 → OctoBot-Trading-2.4.98}/octobot_trading/exchanges/implementations/exchange_simulator.py

@@ -13,6 +13,8 @@
 #
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library.
+import typing
+
 import octobot_trading.constants as constants
 import octobot_trading.exchanges.util as exchange_util
 import octobot_trading.exchanges.connectors.simulator.exchange_simulator_connector as exchange_simulator_connector
@@ -22,12 +24,15 @@ import octobot_trading.exchanges.types.rest_exchange as rest_exchange
 class ExchangeSimulator(rest_exchange.RestExchange):
     DEFAULT_CONNECTOR_CLASS = exchange_simulator_connector.ExchangeSimulatorConnector
 
-    def __init__(self, config, exchange_manager, backtesting):
+    def __init__(
+        self, config, exchange_manager, backtesting,
+        exchange_config_by_exchange: typing.Optional[dict[str, dict]] = None
+    ):
         self.backtesting = backtesting
         self.exchange_importers = []
         self.exchange_tentacle_class = None
         self.exchange_tentacle = None
-        super().__init__(config, exchange_manager)
+        super().__init__(config, exchange_manager, exchange_config_by_exchange)
 
     def _create_connector(self, config, exchange_manager, connector_class):
         return (connector_class or self.DEFAULT_CONNECTOR_CLASS)(
@@ -41,7 +46,7 @@ class ExchangeSimulator(rest_exchange.RestExchange):
         await super().initialize_impl()
         self.exchange_importers = self.connector.exchange_importers
         self.exchange_tentacle_class = exchange_util.get_rest_exchange_class(
-            self.exchange_manager.exchange_name, self.exchange_manager.tentacles_setup_config
+            self.exchange_manager.exchange_name, self.exchange_manager.tentacles_setup_config, None
         )
         if self.connector.should_adapt_market_statuses():
             await self._init_exchange_tentacle()
@@ -54,7 +59,7 @@ class ExchangeSimulator(rest_exchange.RestExchange):
             # initialize a locale exchange_tentacle to be able to access adapters for market statuses
             if self.exchange_tentacle_class:
                 self.exchange_tentacle = self.exchange_tentacle_class(
-                    self.exchange_manager.config, self.exchange_manager
+                    self.exchange_manager.config, self.exchange_manager, None
                 )
         finally:
             self.exchange_manager.ignore_config = origin_ignore_config

{OctoBot-Trading-2.4.97 → OctoBot-Trading-2.4.98}/octobot_trading/exchanges/types/rest_exchange.py

@@ -108,10 +108,13 @@ class RestExchange(abstract_exchange.AbstractExchange):
 
     DEFAULT_CONNECTOR_CLASS = ccxt_connector.CCXTConnector
 
-    def __init__(self, config, exchange_manager, connector_class=None):
-        super().__init__(config, exchange_manager)
+    def __init__(
+        self, config, exchange_manager, exchange_config_by_exchange: typing.Optional[dict[str, dict]],
+        connector_class=None
+    ):
+        super().__init__(config, exchange_manager, exchange_config_by_exchange)
         if self.HAS_FETCHED_DETAILS:
-            self._fetch_details(config, exchange_manager)
+            self._apply_fetched_details(config, exchange_manager)
         self.connector = self._create_connector(config, exchange_manager, connector_class)
         self.pair_contracts = {}
 
@@ -938,8 +941,14 @@ class RestExchange(abstract_exchange.AbstractExchange):
     """
     Auto fetched and filled exchanges
     """
-    def _fetch_details(self, config, exchange_manager):
-        raise NotImplementedError("_fetch_details is not implemented")
+    def _apply_fetched_details(self, config, exchange_manager):
+        raise NotImplementedError("_apply_fetched_details is not implemented")
+
+    @classmethod
+    async def fetch_exchange_config(
+        cls, exchange_config_by_exchange: typing.Optional[dict[str, dict]], exchange_manager
+    ):
+        raise NotImplementedError("fetch_exchange_config")
 
     @staticmethod
     def supported_autofill_exchanges(tentacle_config):

{OctoBot-Trading-2.4.97 → OctoBot-Trading-2.4.98}/octobot_trading/exchanges/util/exchange_util.py

@@ -37,13 +37,20 @@ import octobot_trading.exchanges.exchange_details as exchange_details
 import octobot_trading.exchanges.exchange_builder as exchange_builder
 
 
-def get_rest_exchange_class(exchange_name, tentacles_setup_config):
-    return search_exchange_class_from_exchange_name(exchanges_types.RestExchange, exchange_name, tentacles_setup_config)
+def get_rest_exchange_class(
+    exchange_name: str, tentacles_setup_config, exchange_config_by_exchange: typing.Optional[dict[str, dict]]
+):
+    return search_exchange_class_from_exchange_name(
+        exchanges_types.RestExchange, exchange_name, tentacles_setup_config, exchange_config_by_exchange
+    )
 
 
-def search_exchange_class_from_exchange_name(exchange_class, exchange_name,
-                                             tentacles_setup_config, enable_default=False):
-    exchange_class = get_exchange_class_from_name(exchange_class, exchange_name,  tentacles_setup_config, enable_default)
+def search_exchange_class_from_exchange_name(
+    exchange_class, exchange_name, tentacles_setup_config, exchange_config_by_exchange, enable_default=False
+):
+    exchange_class = get_exchange_class_from_name(
+        exchange_class, exchange_name,  tentacles_setup_config, exchange_config_by_exchange, enable_default
+    )
     if exchange_class is not None:
         return exchange_class
     if enable_default:
@@ -59,8 +66,10 @@ def search_exchange_class_from_exchange_name(exchange_class, exchange_name,
     return exchanges_implementations.DefaultRestExchange
 
 
-def get_exchange_class_from_name(exchange_parent_class, exchange_name, tentacles_setup_config,
-                                 enable_default_implementation, strict_name_matching=False):
+def get_exchange_class_from_name(
+    exchange_parent_class, exchange_name, tentacles_setup_config, exchange_config_by_exchange,
+    enable_default_implementation, strict_name_matching=False
+):
     for exchange_candidate in tentacles_management.get_all_classes_from_parent(exchange_parent_class):
         try:
             if _is_exchange_candidate_matching(
@@ -75,19 +84,21 @@ def get_exchange_class_from_name(exchange_parent_class, exchange_name, tentacles
             # As we are searching for an exchange_type specific subclass
             # We should ignore classes that raises NotImplementedError
             pass
-    auto_filled_exchanges = _get_auto_filled_exchanges(tentacles_setup_config)
+    auto_filled_exchanges = _get_auto_filled_exchanges(tentacles_setup_config, exchange_config_by_exchange)
     if exchange_name in auto_filled_exchanges:
         return auto_filled_exchanges[exchange_name][0]
     return None
 
 
-def _get_auto_filled_exchanges(tentacles_setup_config):
+def _get_auto_filled_exchanges(tentacles_setup_config, exchange_config_by_exchange: typing.Optional[dict[str, dict]]):
     auto_filled_exchanges = {}
     for exchange_candidate in _get_auto_filled_exchanges_tentacles():
         if tentacles_setup_config is None:
             # tentacles_setup_config is required for auto-filled exchanges
             continue
-        config = api.get_tentacle_config(
+        config = exchange_config_by_exchange[exchange_candidate.get_name()] if (
+            exchange_config_by_exchange and exchange_candidate.get_name() in exchange_config_by_exchange
+        ) else api.get_tentacle_config(
             tentacles_setup_config, exchange_candidate
         )
         for exchange_name in exchange_candidate.supported_autofill_exchanges(config):
@@ -96,7 +107,7 @@ def _get_auto_filled_exchanges(tentacles_setup_config):
 
 
 def get_auto_filled_exchange_names(tentacles_setup_config):
-    return list(_get_auto_filled_exchanges(tentacles_setup_config))
+    return list(_get_auto_filled_exchanges(tentacles_setup_config, None))
 
 
 def _get_auto_filled_exchanges_tentacles():
@@ -111,7 +122,7 @@ async def get_exchange_details(
     exchange_name, is_autofilled, tentacles_setup_config, aiohttp_session
 ) -> exchange_details.ExchangeDetails:
     if is_autofilled:
-        auto_filled_exchanges = _get_auto_filled_exchanges(tentacles_setup_config)
+        auto_filled_exchanges = _get_auto_filled_exchanges(tentacles_setup_config, None)
         if exchange_name in auto_filled_exchanges:
             return await auto_filled_exchanges[exchange_name][0].get_autofilled_exchange_details(
                 aiohttp_session, auto_filled_exchanges[exchange_name][1], exchange_name
@@ -208,7 +219,7 @@ def get_enabled_exchanges(config):
 async def get_local_exchange_manager(
     exchange_name: str, exchange_config: dict, tentacles_setup_config,
     is_sandboxed: bool, ignore_config=False, builder=None, use_cached_markets=True,
-    is_broker_enabled: bool = False,
+    is_broker_enabled: bool = False, exchange_config_by_exchange: typing.Optional[dict[str, dict]] = None,
     market_filter: typing.Union[None, typing.Callable[[dict], bool]] = None
 ):
     exchange_type = exchange_config.get(common_constants.CONFIG_EXCHANGE_TYPE, get_default_exchange_type(exchange_name))
@@ -220,6 +231,7 @@ async def get_local_exchange_manager(
         .is_checking_credentials(False) \
         .is_sandboxed(is_sandboxed) \
         .is_using_exchange_type(exchange_type) \
+        .use_exchange_config_by_exchange(exchange_config_by_exchange) \
         .is_exchange_only() \
         .is_rest_only() \
         .is_broker_enabled(is_broker_enabled) \
@@ -344,9 +356,10 @@ def get_default_exchange_type(exchange_name):
     return common_constants.DEFAULT_EXCHANGE_TYPE
 
 
-def get_supported_exchange_types(exchange_name, tentacles_setup_config):
+def get_supported_exchange_types(exchange_name, tentacles_setup_config, exchange_config_by_exchange=None):
     exchange_class = get_exchange_class_from_name(
-        exchanges_types.RestExchange, exchange_name, tentacles_setup_config, False, strict_name_matching=True
+        exchanges_types.RestExchange, exchange_name, tentacles_setup_config,
+        exchange_config_by_exchange, False, strict_name_matching=True
     )
     if exchange_class is None:
         # default

{OctoBot-Trading-2.4.97 → OctoBot-Trading-2.4.98}/octobot_trading/modes/abstract_trading_mode.py

@@ -179,6 +179,13 @@ class AbstractTradingMode(abstract_tentacle.AbstractTentacle):
         """
         return True
 
+    @classmethod
+    def is_ignoring_cancelled_orders_trades(cls) -> bool:
+        """
+        :return: True if trades created by cancelled orders should be ignored and not stored in trades manager
+        """
+        return False
+
     @classmethod
     def get_parent_trading_mode_classes(cls, higher_parent_class_limit=None) -> list:
         return [

{OctoBot-Trading-2.4.97 → OctoBot-Trading-2.4.98}/octobot_trading/personal_data/trades/channel/trades_updater.py

@@ -45,7 +45,7 @@ class TradesUpdater(trades_channel.TradesProducer):
     """
     The default trade history update refresh time in seconds
     """
-    TRADES_REFRESH_TIME = 333
+    TRADES_REFRESH_TIME = 5 * commons_constants.MINUTE_TO_SECONDS
 
     DEPENDENCIES_TIMEOUT = 5 * commons_constants.MINUTE_TO_SECONDS
 
@@ -57,6 +57,7 @@ class TradesUpdater(trades_channel.TradesProducer):
     async def init_trade_history(self):
         try:
             await self.fetch_and_push()
+            self._set_all_initialized()
             await asyncio.sleep(self.TRADES_REFRESH_TIME)
         except errors.NotSupported:
             self.logger.warning(f"{self.channel.exchange_manager.exchange_name} is not supporting updates")
@@ -65,12 +66,18 @@ class TradesUpdater(trades_channel.TradesProducer):
             self.logger.error(f"Fail to initialize trade history : {e}")
 
     async def fetch_and_push(self):
+        self.logger.debug(
+            f"Updating {self.channel.exchange_manager.exchange_config.traded_symbol_pairs} trades history"
+        )
         for symbol in self.channel.exchange_manager.exchange_config.traded_symbol_pairs:
-            trades: list = await self.channel.exchange_manager.exchange.get_my_recent_trades(
+            if trades := await self.channel.exchange_manager.exchange.get_my_recent_trades(
                 symbol=symbol,
-                limit=self.MAX_OLD_TRADES_TO_FETCH)
-            if trades:
+                limit=self.MAX_OLD_TRADES_TO_FETCH
+            ):
                 await self.push(trades)
+
+    def _set_all_initialized(self):
+        for symbol in self.channel.exchange_manager.exchange_config.traded_symbol_pairs:
             if not self._is_initialized_event_set:
                 self._set_initialized_event(symbol)
         self._is_initialized_event_set = True
@@ -98,20 +105,17 @@ class TradesUpdater(trades_channel.TradesProducer):
             )
             await self.init_trade_history()
 
-        # Code bellow shouldn't be necessary
-        # while not self.should_stop and not self.channel.is_paused:
-        #     try:
-        #         for symbol in self.channel.exchange_manager.exchange_config.traded_symbol_pairs:
-        #             trades: list = await self.channel.exchange_manager.exchange.get_my_recent_trades(
-        #                 symbol=symbol,
-        #                 limit=self.TRADES_LIMIT)
-        #
-        #             if trades:
-        #                 await self.push(list(map(self.channel.exchange_manager.exchange.clean_trade, trades)))
-        #     except Exception as e:
-        #         self.logger.error(f"Fail to update trades : {e}")
-        #
-        #     await asyncio.sleep(self.TRADES_REFRESH_TIME)
+        if self.channel.exchange_manager.exchange_config.has_forced_updater(self.CHANNEL_NAME):
+            await self._run_update_loop()
+
+    async def _run_update_loop(self):
+        while not self.should_stop and not self.channel.is_paused:
+            try:
+                await self.fetch_and_push()
+            except Exception as e:
+                self.logger.error(f"Fail to update trades : {e}")
+
+            await asyncio.sleep(self.TRADES_REFRESH_TIME)
 
     async def resume(self) -> None:
         """

{OctoBot-Trading-2.4.97 → OctoBot-Trading-2.4.98}/octobot_trading/personal_data/trades/trades_manager.py

@@ -50,22 +50,34 @@ class TradesManager(util.Initializable):
         self._reset_trades()
         await self._load_trades_history(reset)
 
-    def upsert_trade(self, trade_id, raw_trade):
+    def upsert_trade(self, trade_id: str, raw_trade: dict) -> bool:
         if trade_id not in self.trades:
             created_trade = personal_data.create_trade_instance_from_raw(self.trader, raw_trade)
             if created_trade:
                 if trade_id in self.trades:
                     self.logger.debug(f"Replacement of an existing trade: {self.trades[trade_id].to_dict()} "
                                       f"by {created_trade.to_dict()} on id: {trade_id}")
-                self.trades[trade_id] = created_trade
-                self._check_trades_size()
-                return True
+                return self._add_trade_if_relevant(trade_id, created_trade)
         return False
 
     def upsert_trade_instance(self, trade):
         if trade.trade_id not in self.trades:
-            self.trades[trade.trade_id] = trade
-            self._check_trades_size()
+            self._add_trade_if_relevant(trade.trade_id, trade)
+
+    def _add_trade_if_relevant(self, trade_id: str, trade) -> bool:
+        if (
+            trade.status is enums.OrderStatus.CANCELED
+            and not self.trader.exchange_manager.exchange_config.is_saving_cancelled_orders_as_trade
+        ):
+            self.logger.debug(
+                f"Cancelled order not added in trades history: {trade.trade_type.name} {trade.origin_quantity} "
+                f"{trade.symbol} at {trade.origin_price}"
+            )
+            return False
+        self.trades[trade_id] = trade
+        self._check_trades_size()
+        return True
+
 
     def has_closing_trade_with_exchange_order_id(self, exchange_order_id) -> bool:
         for trade in self.get_trades(exchange_order_id=exchange_order_id):