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

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

@@ -4,6 +4,15 @@ 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.99] - 2024-08-19
+### Updated
+- [CCXT] updated to ccxt 4.3.85
+
+## [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.99/OctoBot_Trading.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: OctoBot-Trading
-Version: 2.4.97
+Version: 2.4.99
 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.99](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.99}/OctoBot_Trading.egg-info/requires.txt

@@ -4,7 +4,7 @@ Async-Channel<2.3,>=2.2
 OctoBot-Commons<1.10,>=1.9.43
 OctoBot-Tentacles-Manager<2.10,>=2.9
 trading-backend>=1.2.7
-ccxt==4.3.56
+ccxt==4.3.85
 cryptography
 sortedcontainers==2.4.0
 tinydb==4.5.2

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: OctoBot-Trading
-Version: 2.4.97
+Version: 2.4.99
 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.99](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.99}/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.99](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.99}/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.99"  # major.minor.revision

{OctoBot-Trading-2.4.97 → OctoBot-Trading-2.4.99}/octobot_trading/api/portfolio.py

@@ -15,6 +15,7 @@
 #  License along with this library.
 import decimal
 
+import octobot_commons.symbols as commons_symbols
 import octobot_trading.exchange_channel as exchange_channel
 import octobot_trading.constants
 import octobot_trading.personal_data as personal_data
@@ -105,4 +106,4 @@ def can_convert_symbol_to_usd_like(symbol: str) -> bool:
 
 
 def is_usd_like_coin(coin) -> bool:
-    return personal_data.ValueConverter.is_usd_like_coin(coin)
+    return commons_symbols.is_usd_like_coin(coin)

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

@@ -121,11 +121,12 @@ TESTED_EXCHANGES = [
     "mexc",
     "bingx",
     "coinex",
+    "bitmart",
 ])
 DEFAULT_FUTURE_EXCHANGES = sorted(["bybit"])
 SIMULATOR_TESTED_EXCHANGES = sorted(["bitfinex2", "bithumb", "bitstamp", "bittrex",
                               "hitbtc", "kraken", "poloniex", "bitso", "ndax", "upbit",
-                              "wavesexchange", "bitmart",])
+                              "wavesexchange",])
 
 # text content of errors due to exchange compliancy rules
 # Warning: should never be a false positive

{OctoBot-Trading-2.4.97 → OctoBot-Trading-2.4.99}/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)
 
@@ -748,4 +750,7 @@ class AbstractExchange(tentacles_management.AbstractTentacle):
     def _get_order_description(
         self, side: enums.TradeOrderSide, symbol: str, quantity: decimal.Decimal, price: decimal.Decimal
     ) -> str:
-        return f"{side.value}-{symbol}-{float(quantity)}-{float(price)}"
+        return (
+            f"{side.value if side else None}-{symbol}-"
+            f"{float(quantity) if quantity else None}-{float(price) if price else None}"
+        )

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

@@ -94,7 +94,7 @@ class AbstractWebsocketExchange:
     def get_exchange_credentials(self):
         """
         Exchange credentials
-        :return: key, secret, password
+        :return: key, secret, password, uid
         """
         return self.exchange_manager.get_exchange_credentials(self.exchange_manager.exchange_name)
 
@@ -219,7 +219,7 @@ class AbstractWebsocketExchange:
         raise NotImplementedError(f"get_feeds_count is not implemented")
 
     def _should_authenticate(self):
-        api_key, api_secret, _ = self.get_exchange_credentials()
+        api_key, api_secret, _, _ = self.get_exchange_credentials()
         return not self.exchange_manager.without_auth \
             and not self.exchange_manager.is_trader_simulated \
             and api_key and api_secret

{OctoBot-Trading-2.4.97 → OctoBot-Trading-2.4.99}/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.99}/octobot_trading/exchanges/connectors/ccxt/ccxt_adapter.py

@@ -43,6 +43,30 @@ class CCXTAdapter(adapters.AbstractAdapter):
         # CCXT standard order parsing logic
         return fixed
 
+    def adapt_amount_from_filled_or_cost(self, fixed):
+        try:
+            if (
+                fixed[enums.ExchangeConstantsOrderColumns.TYPE.value] == enums.TradeOrderType.MARKET.value and
+                fixed[enums.ExchangeConstantsOrderColumns.SIDE.value] == enums.TradeOrderSide.BUY.value and
+                fixed[enums.ExchangeConstantsOrderColumns.FILLED.value]
+            ):
+                # convert amount to use the base unit: use FILLED for accuracy (when not None/0)
+                fixed[enums.ExchangeConstantsOrderColumns.AMOUNT.value] = (
+                    fixed[enums.ExchangeConstantsOrderColumns.FILLED.value]
+                )
+            if (
+                (not fixed[enums.ExchangeConstantsOrderColumns.AMOUNT.value]) and
+                fixed[enums.ExchangeConstantsOrderColumns.COST.value] and
+                fixed[enums.ExchangeConstantsOrderColumns.PRICE.value]
+            ):
+                # convert amount to use the base unit
+                fixed[enums.ExchangeConstantsOrderColumns.AMOUNT.value] = (
+                    fixed[enums.ExchangeConstantsOrderColumns.COST.value] /
+                    fixed[enums.ExchangeConstantsOrderColumns.PRICE.value]
+                )
+        except KeyError:
+            pass
+
     def adapt_quantities_with_contract_size(self, order_or_trade, symbol):
         if self.connector.exchange_manager.is_future:
             symbol = symbol or order_or_trade.get(ecoc.SYMBOL.value)

{OctoBot-Trading-2.4.97 → OctoBot-Trading-2.4.99}/octobot_trading/exchanges/connectors/ccxt/ccxt_client_util.py

@@ -45,15 +45,15 @@ def create_client(
                     f"exchange with ccxt in version {ccxt.__version__}")
     if exchange_manager.ignore_config or exchange_manager.check_config(exchange_manager.exchange_name):
         try:
-            key, secret, password = exchange_manager.get_exchange_credentials(exchange_manager.exchange_name)
+            key, secret, password, uid = exchange_manager.get_exchange_credentials(exchange_manager.exchange_name)
             if keys_adapter:
-                key, secret, password = keys_adapter(key, secret, password)
+                key, secret, password, uid = keys_adapter(key, secret, password, uid)
             if not (key and secret) and not exchange_manager.is_simulated and not exchange_manager.ignore_config:
                 logger.warning(f"No exchange API key set for {exchange_manager.exchange_name}. "
                                f"Enter your account details to enable real trading on this exchange.")
             if should_authenticate and not exchange_manager.is_backtesting:
                 client = exchange_class(_get_client_config(options, headers, additional_config,
-                                                           key, secret, password))
+                                                           key, secret, password, uid))
                 is_authenticated = True
                 if exchange_manager.check_credentials:
                     client.checkRequiredCredentials()
@@ -244,7 +244,7 @@ def _use_http_proxy_if_necessary(client):
     client.aiohttp_trust_env = constants.ENABLE_EXCHANGE_HTTP_PROXY_FROM_ENV
 
 
-def _get_client_config(options, headers, additional_config, api_key=None, secret=None, password=None):
+def _get_client_config(options, headers, additional_config, api_key=None, secret=None, password=None, uid=None):
     config = {
         'verbose': constants.ENABLE_CCXT_VERBOSE,
         'enableRateLimit': constants.ENABLE_CCXT_RATE_LIMIT,
@@ -258,5 +258,7 @@ def _get_client_config(options, headers, additional_config, api_key=None, secret
         config['secret'] = secret
     if password is not None:
         config['password'] = password
+    if uid is not None:
+        config['uid'] = uid
     config.update(additional_config or {})
     return config

{OctoBot-Trading-2.4.97 → OctoBot-Trading-2.4.99}/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.99}/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.99}/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.99}/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.99}/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()
 
@@ -306,7 +306,7 @@ class ExchangeManager(util.Initializable):
 
     def get_exchange_credentials(self, exchange_name):
         if self.ignore_config or not self.should_decrypt_token() or self.without_auth:
-            return "", "", ""
+            return "", "", "", ""
         config_exchange = self.config[common_constants.CONFIG_EXCHANGES][exchange_name]
         return (
             configuration.decrypt_element_if_possible(
@@ -317,7 +317,8 @@ class ExchangeManager(util.Initializable):
             ).strip(" "),   # remove leading and trailing whitespaces if any
             configuration.decrypt_element_if_possible(
                 common_constants.CONFIG_EXCHANGE_PASSWORD, config_exchange, None
-            )
+            ),
+            config_exchange.get(common_constants.CONFIG_EXCHANGE_UID, "")
         )
 
     def get_exchange_sub_account_id(self, exchange_name):

{OctoBot-Trading-2.4.97 → OctoBot-Trading-2.4.99}/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.99}/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.99}/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.99}/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 [