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

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

@@ -4,6 +4,19 @@ 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
+- [Exchanges] forced ticker setting 
+- [API] get_daily_base_and_quote_volume
+### Fixed
+- [Exchanges] ticker volumes
+
 ## [2.4.96] - 2024-08-13
 ### Added
 - [Exchanges] BitMart tests

{OctoBot-Trading-2.4.96 → 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.96
+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.96](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.96/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.96
+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.96](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.96 → OctoBot-Trading-2.4.98}/README.md

@@ -1,4 +1,4 @@
-# OctoBot-Trading [2.4.96](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.96 → 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.96"  # major.minor.revision
+VERSION = "2.4.98"  # major.minor.revision

{OctoBot-Trading-2.4.96 → OctoBot-Trading-2.4.98}/octobot_trading/api/__init__.py

@@ -42,6 +42,7 @@ from octobot_trading.api.symbol_data import (
     get_symbol_high_candles,
     get_symbol_low_candles,
     get_symbol_volume_candles,
+    get_daily_base_and_quote_volume,
     get_symbol_time_candles,
     create_new_candles_manager,
     force_set_mark_price,
@@ -232,6 +233,7 @@ __all__ = [
     "get_symbol_high_candles",
     "get_symbol_low_candles",
     "get_symbol_volume_candles",
+    "get_daily_base_and_quote_volume",
     "get_symbol_time_candles",
     "create_new_candles_manager",
     "force_set_mark_price",

{OctoBot-Trading-2.4.96 → OctoBot-Trading-2.4.98}/octobot_trading/api/exchange.py

@@ -78,7 +78,7 @@ def get_exchange_configuration_from_exchange_id(exchange_id: str) -> exchanges.E
 
 
 # prefer get_exchange_manager_from_exchange_name_and_id when possible
-def get_exchange_manager_from_exchange_id(exchange_id: str) -> object:
+def get_exchange_manager_from_exchange_id(exchange_id: str) -> exchanges.ExchangeManager:
     try:
         return get_exchange_configuration_from_exchange_id(exchange_id).exchange_manager
     except KeyError:

{OctoBot-Trading-2.4.96 → OctoBot-Trading-2.4.98}/octobot_trading/api/symbol_data.py

@@ -94,6 +94,32 @@ def get_symbol_volume_candles(symbol_data, time_frame, limit=-1, include_in_cons
     return exchange_data.get_symbol_volume_candles(symbol_data, time_frame, limit, include_in_construction)
 
 
+def get_daily_base_and_quote_volume(symbol_data, reference_price: decimal.Decimal) -> (decimal.Decimal, decimal.Decimal):
+    base_volume = symbol_data.ticker_manager.ticker.get(
+        octobot_trading.enums.ExchangeConstantsTickersColumns.BASE_VOLUME.value,
+        "nan"
+    )
+    quote_volume = symbol_data.ticker_manager.ticker.get(
+        octobot_trading.enums.ExchangeConstantsTickersColumns.QUOTE_VOLUME.value,
+        "nan"
+    )
+    if base_volume:
+        base_volume = decimal.Decimal(str(base_volume))
+        if not quote_volume or decimal.Decimal(str(quote_volume)).is_nan():
+            # compute from the other if missing
+            quote_volume = base_volume * reference_price
+    if quote_volume:
+        quote_volume = decimal.Decimal(str(quote_volume))
+        if not base_volume or decimal.Decimal(str(base_volume)).is_nan():
+            # compute from the other if missing
+            base_volume = quote_volume / reference_price
+    if not (base_volume and quote_volume):
+        raise ValueError(
+            f"Missing volume {base_volume=} {quote_volume=}"
+        )
+    return base_volume, quote_volume
+
+
 def get_symbol_time_candles(symbol_data, time_frame, limit=-1, include_in_construction=False):
     return exchange_data.get_symbol_time_candles(symbol_data, time_frame, limit, include_in_construction)
 

{OctoBot-Trading-2.4.96 → OctoBot-Trading-2.4.98}/octobot_trading/exchange_data/exchange_symbols_data.py

@@ -33,7 +33,7 @@ class ExchangeSymbolsData:
             exchange_symbol_data.stop()
         self.exchange_symbol_data = {}
 
-    def get_exchange_symbol_data(self, symbol, allow_creation=True):
+    def get_exchange_symbol_data(self, symbol, allow_creation=True) -> ExchangeSymbolData:
         try:
             return self.exchange_symbol_data[symbol]
         except KeyError as e:

{OctoBot-Trading-2.4.96 → OctoBot-Trading-2.4.98}/octobot_trading/exchange_data/prices/prices_manager.py

@@ -89,7 +89,13 @@ class PricesManager(util.Initializable):
                 (mark_price, self.exchange_manager.exchange.get_exchange_current_time())
         return is_mark_price_updated
 
-    async def get_mark_price(self, timeout=MARK_PRICE_FETCH_TIMEOUT):
+    def get_mark_price_no_wait(self) -> decimal.Decimal:
+        self._ensure_price_validity()
+        if not self.valid_price_received_event.is_set():
+            raise ValueError(f"No up to date mark price for {self.exchange_manager.exchange_name}")
+        return self.mark_price
+
+    async def get_mark_price(self, timeout=MARK_PRICE_FETCH_TIMEOUT) -> decimal.Decimal:
         """
         Return mark price if valid
         :param timeout: event wait timeout

{OctoBot-Trading-2.4.96 → OctoBot-Trading-2.4.98}/octobot_trading/exchange_data/ticker/channel/ticker_updater.py

@@ -95,11 +95,12 @@ class TickerUpdater(ticker_channel.TickerProducer):
     """
 
     def _should_use_future(self):
-        return self.channel.exchange_manager.is_future and \
-               (
-                       self.channel.exchange_manager.exchange.FUNDING_IN_TICKER
-                       or self.channel.exchange_manager.exchange.MARK_PRICE_IN_TICKER
-               )
+        return (
+            self.channel.exchange_manager.is_future and (
+                self.channel.exchange_manager.exchange.FUNDING_IN_TICKER
+                or self.channel.exchange_manager.exchange.MARK_PRICE_IN_TICKER
+            )
+        )
 
     async def modify(self, added_pairs=None, removed_pairs=None):
         if added_pairs:

{OctoBot-Trading-2.4.96 → OctoBot-Trading-2.4.98}/octobot_trading/exchange_data/ticker/ticker_manager.py

@@ -62,7 +62,12 @@ class TickerManager(util.Initializable):
         }
 
     def ticker_update(self, ticker):
-        self.ticker.update(ticker)
+        ticker_update = {
+            key: val
+            for key, val in ticker.items()
+            if val
+        }
+        self.ticker.update(ticker_update)
 
     def mini_ticker_update(self, mini_ticker):
         self.mini_ticker.update(mini_ticker)

{OctoBot-Trading-2.4.96 → 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
@@ -95,8 +95,10 @@ class AbstractExchange(tentacles_management.AbstractTentacle):
 
         self.is_unreachable = False
 
-        self._creating_exchange_order_ids = set()
+        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)
 
@@ -327,6 +329,13 @@ class AbstractExchange(tentacles_management.AbstractTentacle):
         """
         raise NotImplementedError("get_leverage_tiers is not implemented")
 
+    async def cancel_all_orders(self, symbol: str = None, **kwargs: dict) -> None:
+        """
+        Cancel all orders on the exchange
+        :param symbol: the orders symbol
+        """
+        raise NotImplementedError("cancel_all_orders is not implemented")
+
     async def cancel_order(
             self, exchange_order_id: str, symbol: str, order_type: enums.TraderOrderType, **kwargs: dict
     ) -> enums.OrderStatus:
@@ -720,17 +729,25 @@ class AbstractExchange(tentacles_management.AbstractTentacle):
                           f"({error.__class__.__name__}: {error})")
 
     @contextlib.contextmanager
-    def creating_order(self, creating_order: dict):
-        exchange_order_id = creating_order.get(
-            enums.ExchangeConstantsOrderColumns.EXCHANGE_ID.value
-        ) if creating_order else None
+    def creating_order(
+        self, side: enums.TradeOrderSide, symbol: str, quantity: decimal.Decimal, price: decimal.Decimal
+    ):
+        desc = self._get_order_description(side, symbol, quantity, price)
         try:
-            self._creating_exchange_order_ids.add(exchange_order_id)
+            self._creating_exchange_order_descriptions.add(desc)
             yield
         finally:
-            self._creating_exchange_order_ids.remove(exchange_order_id)
-
-    def is_creating_order(self, exchange_order_id):
-        if exchange_order_id is None:
-            return False
-        return exchange_order_id in self._creating_exchange_order_ids
+            self._creating_exchange_order_descriptions.remove(desc)
+
+    def is_creating_order(
+        self, order: dict, symbol: str
+    ) -> bool:
+        quantity = decimal.Decimal(str(order[enums.ExchangeConstantsOrderColumns.AMOUNT.value]))
+        price = decimal.Decimal(str(order[enums.ExchangeConstantsOrderColumns.PRICE.value]))
+        side = enums.TradeOrderSide(str(order[enums.ExchangeConstantsOrderColumns.SIDE.value]))
+        return self._get_order_description(side, symbol, quantity, price) in self._creating_exchange_order_descriptions
+
+    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)}"

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

@@ -65,6 +65,12 @@ class ExchangeConfig(util.Initializable):
         # number of required historical candles
         self.required_historical_candles_count = constants.DEFAULT_IGNORED_VALUE
 
+        # 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):
@@ -141,6 +147,15 @@ class ExchangeConfig(util.Initializable):
         # If required timeframes: use those. Use traded timeframes otherwise
         return self.available_required_time_frames or self.traded_time_frames
 
+    def has_forced_updater(self, channel: str) -> bool:
+        return channel in self.forced_updater_channels
+
+    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.96 → 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)
@@ -571,6 +571,19 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
             symbol=symbol, quantity=quantity
         )
 
+    @ccxt_client_util.converted_ccxt_common_errors
+    async def cancel_all_orders(self, symbol: str = None, **kwargs: dict) -> None:
+        try:
+            with self.error_describer():
+                await self.client.cancel_all_orders(symbol=symbol, params=kwargs)
+        except (ccxt.NotSupported, octobot_trading.errors.NotSupported) as e:
+            raise octobot_trading.errors.NotSupported(e) from e
+        except Exception as e:
+            self.logger.exception(
+                e, True, f"Unexpected error when cancelling all {symbol} orders | {e} ({e.__class__.__name__})"
+            )
+            raise e
+
     @ccxt_client_util.converted_ccxt_common_errors
     async def cancel_order(
         self, exchange_order_id: str, symbol: str, order_type: enums.TraderOrderType, **kwargs: dict

{OctoBot-Trading-2.4.96 → OctoBot-Trading-2.4.98}/octobot_trading/exchanges/connectors/ccxt/ccxt_websocket_connector.py

@@ -926,7 +926,8 @@ class CCXTWebsocketConnector(abstract_websocket_exchange.AbstractWebsocketExchan
                 Ectc.CLOSE.value: kline[commons_enums.PriceIndexes.IND_PRICE_CLOSE.value],
                 Ectc.LAST.value: kline[commons_enums.PriceIndexes.IND_PRICE_CLOSE.value],
                 Ectc.PREVIOUS_CLOSE.value: None,
-                Ectc.BASE_VOLUME.value: kline[commons_enums.PriceIndexes.IND_PRICE_VOL.value],
+                # do not include volume as this is not the ticker volume but the current candle volume
+                Ectc.BASE_VOLUME.value: None,
                 Ectc.TIMESTAMP.value: self.exchange.get_exchange_current_time(),
             }
             await self.push_to_channel(

{OctoBot-Trading-2.4.96 → 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.96 → 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)
 
@@ -106,6 +109,13 @@ class ExchangeBuilder:
             self.config[commons_constants.CONFIG_TENTACLES_REQUIRED_CANDLES_COUNT],
             modes.get_required_candles_count(trading_mode_class, tentacles_setup_config)
         )
+        # register forced updaters if any
+        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:
@@ -266,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.96 → 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.96 → 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.96 → OctoBot-Trading-2.4.98}/octobot_trading/exchanges/exchange_websocket_factory.py

@@ -34,14 +34,16 @@ def is_channel_managed_by_websocket(exchange_manager, channel):
 def is_channel_fully_managed_by_websocket(exchange_manager, channel):
     return (
         not any([
+            # no associated feed is related to a time frame
             exchange_manager.exchange_web_socket.is_time_frame_related_feed(feed)
             for feed in octobot_trading.constants.WEBSOCKET_FEEDS_TO_TRADING_CHANNELS[channel]
         ])
         or all([
+            # all required time frames are supported
             exchange_manager.exchange_web_socket.is_time_frame_supported(time_frame)
             for time_frame in exchange_manager.exchange_config.available_time_frames
         ])
-    )
+    ) and not exchange_manager.exchange_config.has_forced_updater(channel)
 
 
 def is_websocket_feed_requiring_init(exchange_manager, channel):

{OctoBot-Trading-2.4.96 → 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.96 → OctoBot-Trading-2.4.98}/octobot_trading/exchanges/traders/trader.py

@@ -459,6 +459,58 @@ class Trader(util.Initializable):
                 f"Can't cancel order and unknown post sync order state for order: {order}."
             ) from err
 
+    async def cancel_all_orders(
+        self,
+        symbol: str,
+        allow_single_order_cancel_fallback: bool,
+        wait_for_cancelling: bool = True,
+        cancelling_timeout: float = octobot_trading.constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT
+    ) -> bool:
+        orders_to_cancel = self.exchange_manager.exchange_personal_data.orders_manager.get_all_orders(symbol)
+        success = True
+        if orders_to_cancel:
+            self.logger.info(f"Cancelling all {len(orders_to_cancel)} {symbol} orders")
+        else:
+            return success
+        try:
+            cancel_on_exchange = False
+            for order in orders_to_cancel:
+                await order.lock.acquire()
+                if self.simulate or order.is_self_managed():
+                    order.status = octobot_trading.enums.OrderStatus.CANCELED
+                else:
+                    cancel_on_exchange = True
+            if cancel_on_exchange:
+                try:
+                    success = False
+                    await self.exchange_manager.exchange.cancel_all_orders(symbol)
+                    success = True
+                except errors.NotSupported:
+                    if allow_single_order_cancel_fallback:
+                        self.logger.debug(
+                            f"cancel_all_orders is not supported on {self.exchange_manager.exchange_name}. Falling "
+                            f"back to one by one cancel"
+                        )
+                        for order in orders_to_cancel:
+                            if not await self.cancel_order(
+                                order.symbol,
+                                wait_for_cancelling=wait_for_cancelling,
+                                cancelling_timeout=cancelling_timeout
+                            ):
+                                success = False
+                    else:
+                        # not supported and no fallback allowed: re-raise errors.NotSupported
+                        raise
+            for order in orders_to_cancel:
+                await order.on_cancel(force_cancel=True, is_from_exchange_data=False)
+                if wait_for_cancelling and order.state is not None and order.state.is_pending():
+                    await self._wait_for_order_cancel(order, cancelling_timeout)
+        finally:
+            for order in orders_to_cancel:
+                order.lock.release()
+        self.logger.info(f"Cancelling of all {len(orders_to_cancel)} {symbol} orders complete")
+        return success
+
     async def _wait_for_order_cancel(self, order, cancelling_timeout):
         self.logger.debug(f"Waiting for order cancelling, order: {order}")
         await order.state.wait_for_terminate(cancelling_timeout)