OctoBot-Trading 2.4.210__tar.gz → 2.4.211__tar.gz

{OctoBot-Trading-2.4.210 → OctoBot-Trading-2.4.211}/CHANGELOG.md

@@ -4,6 +4,10 @@ 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.211] - 2025-08-24
+### Added
+[Signals] add dependencies
+
 ## [2.4.210] - 2025-08-22
 ### Added
 [TradingModes] add get_trading_modes_of_this_type_on_this_matrix

{OctoBot-Trading-2.4.210 → OctoBot-Trading-2.4.211/OctoBot_Trading.egg-info}/PKG-INFO

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

@@ -1,7 +1,7 @@
 numpy==1.26.3
 OctoBot-Backtesting<1.10,>=1.9
 Async-Channel<2.3,>=2.2
-OctoBot-Commons<1.10,>=1.9.64
+OctoBot-Commons<1.10,>=1.9.82
 OctoBot-Tentacles-Manager<2.10,>=2.9
 trading-backend>=1.2.35
 ccxt==4.5.0

{OctoBot-Trading-2.4.210/OctoBot_Trading.egg-info → OctoBot-Trading-2.4.211}/PKG-INFO

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

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

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

{OctoBot-Trading-2.4.210 → OctoBot-Trading-2.4.211}/octobot_trading/api/orders.py

@@ -14,8 +14,10 @@
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library.
 import decimal
+import typing
 
 import octobot_commons.logging as logging
+import octobot_commons.signals as signals
 
 import octobot_trading.personal_data as personal_data
 import octobot_trading.enums
@@ -32,7 +34,7 @@ async def create_order(exchange_manager,
                        quantity: float,
                        price: float,
                        wait_for_creation=True,
-                       creation_timeout=octobot_trading.constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT) -> personal_data.Order:
+                       creation_timeout=constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT) -> personal_data.Order:
     return await exchange_manager.trader.create_order(
         exchange_manager.trader.create_order_instance(order_type=order_type,
                                                       symbol=symbol,
@@ -56,17 +58,24 @@ def get_pending_creation_orders(exchange_manager) -> list:
     return exchange_manager.exchange_personal_data.orders_manager.pending_creation_orders
 
 
-async def cancel_all_open_orders(exchange_manager, emit_trading_signals=True) -> bool:
+async def cancel_all_open_orders(exchange_manager, emit_trading_signals=True) -> tuple[bool, list]:
     return await exchange_manager.trader.cancel_all_open_orders(emit_trading_signals=emit_trading_signals)
 
 
-async def cancel_all_open_orders_with_currency(exchange_manager, currency, emit_trading_signals=True) -> bool:
-    return await exchange_manager.trader.cancel_all_open_orders_with_currency(currency, emit_trading_signals=emit_trading_signals)
+async def cancel_all_open_orders_with_currency(
+    exchange_manager, currency, emit_trading_signals=True, dependencies=None
+) -> tuple[bool, signals.SignalDependencies]:
+    return await exchange_manager.trader.cancel_all_open_orders_with_currency(
+        currency, emit_trading_signals=emit_trading_signals, dependencies=dependencies
+    )
 
 
-async def cancel_order_with_id(exchange_manager, order_id, emit_trading_signals=True, wait_for_cancelling=True) -> bool:
-    return await exchange_manager.trader.cancel_order_with_id(order_id, emit_trading_signals=emit_trading_signals,
-                                                              wait_for_cancelling=wait_for_cancelling)
+async def cancel_order_with_id(
+    exchange_manager, order_id, emit_trading_signals=True, wait_for_cancelling=True, dependencies=None
+) -> tuple[bool, typing.Optional[signals.SignalDependencies]]:
+    return await exchange_manager.trader.cancel_order_with_id(
+        order_id, emit_trading_signals=emit_trading_signals, wait_for_cancelling=wait_for_cancelling, dependencies=dependencies
+    )
 
 
 def get_order_exchange_name(order) -> str:

{OctoBot-Trading-2.4.210 → OctoBot-Trading-2.4.211}/octobot_trading/enums.py

@@ -593,6 +593,11 @@ class TradingSignalOrdersActions(enum.Enum):
     CANCEL = "cancel"
 
 
+class TradingSignalDependencies(enum.Enum):
+    ORDER_ID = "order_id"
+    POSITION_SYMBOL = "position_symbol"
+
+
 class TradingSignalPositionsActions(enum.Enum):
     EDIT = "edit"
 

{OctoBot-Trading-2.4.210 → OctoBot-Trading-2.4.211}/octobot_trading/exchanges/traders/trader.py

@@ -20,6 +20,7 @@ import typing
 
 import octobot_commons.logging as logging
 import octobot_commons.html_util as html_util
+import octobot_commons.signals as commons_signals
 import octobot_commons.constants
 
 import octobot_trading.personal_data.orders.order_factory as order_factory
@@ -142,7 +143,8 @@ class Trader(util.Initializable):
     async def create_artificial_order(
         self, order_type, symbol, current_price, quantity, price, reduce_only, close_position,
         emit_trading_signals=False, wait_for_creation=True,
-        creation_timeout=octobot_trading.constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT
+        creation_timeout=octobot_trading.constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT,
+        dependencies: typing.Optional[commons_signals.SignalDependencies] = None
     ):
         """
         Creates an OctoBot managed order (managed orders example: stop loss that is not published on the exchange and
@@ -164,7 +166,8 @@ class Trader(util.Initializable):
                 emit_trading_signals and signals.should_emit_trading_signal(self.exchange_manager),
                 order,
                 wait_for_creation=wait_for_creation,
-                creation_timeout=creation_timeout
+                creation_timeout=creation_timeout,
+                dependencies=dependencies
             )
 
     async def edit_order(self, order,
@@ -435,7 +438,7 @@ class Trader(util.Initializable):
 
     async def update_order_as_active(
         self, order, params: dict = None, wait_for_creation=True, raise_all_creation_error=False,
-        creation_timeout=octobot_trading.constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT
+        creation_timeout=octobot_trading.constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT,
     ):
         if not self.enable_inactive_orders:
             self.logger.error(f"Can't update order as active when {self.enable_inactive_orders=}.")
@@ -512,17 +515,17 @@ class Trader(util.Initializable):
                 return False
             is_order_refreshing = order.is_refreshing()
             if order_status is enums.OrderStatus.CANCELED:
-                order.status = octobot_trading.enums.OrderStatus.CANCELED
+                order.status = enums.OrderStatus.CANCELED
                 self.logger.debug(f"Successfully cancelled order {order}")
             elif order_status is enums.OrderStatus.PENDING_CANCEL:
-                order.status = octobot_trading.enums.OrderStatus.PENDING_CANCEL
+                order.status = enums.OrderStatus.PENDING_CANCEL
                 self.logger.debug(f"Order cancel in progress for {order}")
         else:
-            order.status = octobot_trading.enums.OrderStatus.CANCELED
+            order.status = enums.OrderStatus.CANCELED
 
         if not is_order_refreshing:
             # don't override state if order is already refreshing (most likely from open orders updater)
-            await order.on_cancel(force_cancel=order.status is octobot_trading.enums.OrderStatus.CANCELED,
+            await order.on_cancel(force_cancel=order.status is enums.OrderStatus.CANCELED,
                                   is_from_exchange_data=False,
                                   ignored_order=ignored_order)
         if wait_for_cancelling and (order.is_refreshing() or order.is_pending()):
@@ -618,7 +621,7 @@ class Trader(util.Initializable):
             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
+                    order.status = enums.OrderStatus.CANCELED
                 else:
                     cancel_on_exchange = True
             if cancel_on_exchange:
@@ -657,16 +660,19 @@ class Trader(util.Initializable):
         await order.state.wait_for_terminate(cancelling_timeout)
         self.logger.debug(f"Completed order cancelling, order: {order}")
 
-    async def cancel_order_with_id(self, exchange_order_id, emit_trading_signals=False,
-                                   wait_for_cancelling=True,
-                                   cancelling_timeout=octobot_trading.constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT):
+    async def cancel_order_with_id(
+        self, exchange_order_id, emit_trading_signals=False,
+        wait_for_cancelling=True,
+        cancelling_timeout=octobot_trading.constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT,
+        dependencies: typing.Optional[commons_signals.SignalDependencies] = None
+    ) -> tuple[bool, typing.Optional[commons_signals.SignalDependencies]]:
         """
         Gets order matching order_id from the OrderManager and calls self.cancel_order() on it
         :param exchange_order_id: Exchange id of the order to cancel
         :param emit_trading_signals: when true, trading signals will be emitted
         :param wait_for_cancelling: when True, always make sure the order is completely cancelled before returning.
         :param cancelling_timeout: time before raising a timeout error when waiting for an order cancel
-        :return: True if cancel is successful, False if order is not found or cancellation failed
+        :return: (True if cancel is successful, False if order is not found or cancellation failed, dependency_id)
         """
         try:
             order = self.exchange_manager.exchange_personal_data.orders_manager.get_order(exchange_order_id)
@@ -677,17 +683,20 @@ class Trader(util.Initializable):
                     order,
                     wait_for_cancelling=wait_for_cancelling,
                     cancelling_timeout=cancelling_timeout,
+                    dependencies=dependencies
                 )
         except KeyError:
-            return False
+            return False, None
 
-    async def cancel_open_orders(self, symbol, cancel_loaded_orders=True, side=None,
-                                 emit_trading_signals=False,
-                                 wait_for_cancelling=True,
-                                 cancelling_timeout=octobot_trading.constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT, 
-                                 since: typing.Union[int, float] = octobot_trading.constants.NO_DATA_LIMIT, 
-                                 until: typing.Union[int, float] = octobot_trading.constants.NO_DATA_LIMIT
-                                 ) -> (bool, list):
+    async def cancel_open_orders(
+        self, symbol, cancel_loaded_orders=True, side=None,
+        emit_trading_signals=False,
+        wait_for_cancelling=True,
+        cancelling_timeout=octobot_trading.constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT, 
+        since: typing.Union[int, float] = octobot_trading.constants.NO_DATA_LIMIT, 
+        until: typing.Union[int, float] = octobot_trading.constants.NO_DATA_LIMIT,
+        dependencies: typing.Optional[commons_signals.SignalDependencies] = None
+    ) -> tuple[bool, list]:
         """
         Should be called only if the goal is to cancel all open orders for a given symbol
         :param symbol: The symbol to cancel all orders on
@@ -708,12 +717,14 @@ class Trader(util.Initializable):
                     (cancel_loaded_orders or order.is_from_this_octobot):
                 try:
                     async with signals.remote_signal_publisher(self.exchange_manager, order.symbol, emit_trading_signals):
-                        cancelled = await signals.cancel_order(
+                        cancelled, _ = await signals.cancel_order(
                             self.exchange_manager,
                             emit_trading_signals and signals.should_emit_trading_signal(self.exchange_manager),
                             order,
                             wait_for_cancelling=wait_for_cancelling,
-                            cancelling_timeout=cancelling_timeout, )
+                            cancelling_timeout=cancelling_timeout,
+                            dependencies=dependencies
+                        )
                     if cancelled:
                         cancelled_orders.append(order)
                     all_cancelled = cancelled and all_cancelled
@@ -725,7 +736,7 @@ class Trader(util.Initializable):
         self, currency, emit_trading_signals=False,
         wait_for_cancelling=True,
         cancelling_timeout=octobot_trading.constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT
-    ) -> bool:
+    ) -> tuple[bool, commons_signals.SignalDependencies]:
         """
         Should be called only if the goal is to cancel all open orders for each traded symbol containing the
         given currency.
@@ -737,48 +748,59 @@ class Trader(util.Initializable):
         """
         all_cancelled = True
         symbols = util.get_pairs(self.config, currency, enabled_only=True)
+        cancelled_dependencies = commons_signals.SignalDependencies()
         if symbols:
             for symbol in symbols:
-                all_cancelled = (await self.cancel_open_orders(symbol, emit_trading_signals=emit_trading_signals,
-                                                               wait_for_cancelling=wait_for_cancelling,
-                                                               cancelling_timeout=cancelling_timeout))[0] \
-                                and all_cancelled
-        return all_cancelled
+                new_all_cancelled, cancelled_orders = await self.cancel_open_orders(
+                    symbol, emit_trading_signals=emit_trading_signals,
+                    wait_for_cancelling=wait_for_cancelling,
+                    cancelling_timeout=cancelling_timeout
+                )
+                all_cancelled = new_all_cancelled and all_cancelled
+                cancelled_dependencies.extend(signals.get_orders_dependencies(cancelled_orders))
+        return all_cancelled, cancelled_dependencies
 
     async def cancel_all_open_orders(
-            self, emit_trading_signals=False,
-            wait_for_cancelling=True,
-            cancelling_timeout=octobot_trading.constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT
-    ) -> bool:
+        self, emit_trading_signals=False,
+        wait_for_cancelling=True,
+        cancelling_timeout=octobot_trading.constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT,
+        dependencies: typing.Optional[commons_signals.SignalDependencies] = None
+    ) -> tuple[bool, commons_signals.SignalDependencies]:
         """
         Cancel all open orders registered on this bot.
         :param emit_trading_signals: when true, trading signals will be emitted
         :param wait_for_cancelling: when True, always make sure the order is completely cancelled before returning.
         :param cancelling_timeout: time before raising a timeout error when waiting for an order cancel
-        :return: True if all orders got cancelled, False if an error occurred
+        :return: (True if all orders got cancelled, False if an error occurred and dependencies)
         """
         all_cancelled = True
+        dependencies = commons_signals.SignalDependencies()
         for order in self.exchange_manager.exchange_personal_data.orders_manager.get_open_orders():
             if not order.is_cancelled():
                 try:
                     async with signals.remote_signal_publisher(
                             self.exchange_manager, order.symbol, emit_trading_signals
                     ):
-                        all_cancelled = await signals.cancel_order(
+                        cancelled, new_dependencies = await signals.cancel_order(
                             self.exchange_manager,
                             emit_trading_signals and signals.should_emit_trading_signal(self.exchange_manager),
                             order,
                             wait_for_cancelling=wait_for_cancelling,
-                            cancelling_timeout=cancelling_timeout, ) and all_cancelled
+                            cancelling_timeout=cancelling_timeout,
+                            dependencies=dependencies
+                        )
+                        if cancelled:
+                            dependencies.extend(new_dependencies)
+                        all_cancelled = cancelled and all_cancelled
                 except (errors.OrderCancelError, errors.UnexpectedExchangeSideOrderStateError) as err:
                     self.logger.warning(f"Skipping order cancel: {err} ({err.__class__.__name__})")
                     all_cancelled = False
-        return all_cancelled
+        return all_cancelled, dependencies
 
     async def _sell_everything(self, symbol, inverted, timeout=None):
         created_orders = []
-        order_type = octobot_trading.enums.TraderOrderType.BUY_MARKET \
-            if inverted else octobot_trading.enums.TraderOrderType.SELL_MARKET
+        order_type = enums.TraderOrderType.BUY_MARKET \
+            if inverted else enums.TraderOrderType.SELL_MARKET
         async with self.exchange_manager.exchange_personal_data.portfolio_manager.portfolio.lock:
             current_symbol_holding, current_market_quantity, _, price, symbol_market = \
                 await order_util.get_pre_order_data(self.exchange_manager, symbol, timeout=timeout)
@@ -839,9 +861,12 @@ class Trader(util.Initializable):
     Positions
     """
 
-    async def close_position(self, position, limit_price=None, timeout=1, emit_trading_signals=False,
-                             wait_for_creation=True,
-                             creation_timeout=octobot_trading.constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT):
+    async def close_position(
+        self, position, limit_price=None, timeout=1, emit_trading_signals=False,
+        wait_for_creation=True,
+        creation_timeout=octobot_trading.constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT,
+        dependencies: typing.Optional[commons_signals.SignalDependencies] = None
+    ):
         """
         Creates a close position order
         :param position: the position to close
@@ -885,7 +910,8 @@ class Trader(util.Initializable):
                         emit_trading_signals and signals.should_emit_trading_signal(self.exchange_manager),
                         current_order,
                         wait_for_creation=wait_for_creation,
-                        creation_timeout=creation_timeout
+                        creation_timeout=creation_timeout,
+                        dependencies=dependencies
                     )
                 created_orders.append(order)
         return created_orders

{OctoBot-Trading-2.4.210 → OctoBot-Trading-2.4.211}/octobot_trading/modes/abstract_trading_mode.py

@@ -24,6 +24,7 @@ import octobot_commons.enums as common_enums
 import octobot_commons.logging as logging
 import octobot_commons.tentacles_management as abstract_tentacle
 import octobot_commons.configuration
+import octobot_commons.signals as commons_signals
 
 import async_channel.constants as channel_constants
 import async_channel.channels as channels
@@ -563,20 +564,27 @@ class AbstractTradingMode(abstract_tentacle.AbstractTentacle):
              as signal_builder:
             yield signal_builder
 
-    async def create_order(self, order, loaded: bool = False, params: dict = None,
-                           wait_for_creation=True,
-                           creation_timeout=constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT):
+    async def create_order(
+        self, order, loaded: bool = False, params: dict = None,
+        wait_for_creation=True, creation_timeout=constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT,
+        dependencies: typing.Optional[commons_signals.SignalDependencies] = None
+    ):
         return await signals.create_order(
             self.exchange_manager, self.should_emit_trading_signal(), order,
             loaded=loaded, params=params,
-            wait_for_creation=wait_for_creation, creation_timeout=creation_timeout
+            wait_for_creation=wait_for_creation, creation_timeout=creation_timeout,
+            dependencies=dependencies
         )
 
-    async def cancel_order(self, order, ignored_order: object = None, wait_for_cancelling: bool = True) -> bool:
+    async def cancel_order(
+        self, order, ignored_order: object = None, wait_for_cancelling: bool = True,
+        dependencies: typing.Optional[commons_signals.SignalDependencies] = None
+    ) -> tuple[bool, commons_signals.SignalDependencies]:
         return await signals.cancel_order(
             self.exchange_manager, self.should_emit_trading_signal(), order,
             ignored_order=ignored_order,
-            wait_for_cancelling=wait_for_cancelling
+            wait_for_cancelling=wait_for_cancelling,
+            dependencies=dependencies
         )
 
     async def cancel_all_orders(
@@ -584,36 +592,41 @@ class AbstractTradingMode(abstract_tentacle.AbstractTentacle):
         symbol: str,
         allow_single_order_cancel_fallback: bool,
         wait_for_cancelling: bool = True,
-        cancelling_timeout: float = constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT
+        cancelling_timeout: float = constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT,
     ) -> bool:
         # todo send signals when implementation will be necessary
         return await self.exchange_manager.trader.cancel_all_orders(
             symbol,
             allow_single_order_cancel_fallback,
             wait_for_cancelling=wait_for_cancelling,
-            cancelling_timeout=cancelling_timeout
+            cancelling_timeout=cancelling_timeout,
         )
 
-    async def edit_order(self, order,
-                         edited_quantity: decimal.Decimal = None,
-                         edited_price: decimal.Decimal = None,
-                         edited_stop_price: decimal.Decimal = None,
-                         edited_current_price: decimal.Decimal = None,
-                         params: dict = None) -> bool:
+    async def edit_order(
+        self, order,
+        edited_quantity: decimal.Decimal = None,
+        edited_price: decimal.Decimal = None,
+        edited_stop_price: decimal.Decimal = None,
+        edited_current_price: decimal.Decimal = None,
+        params: dict = None,
+        dependencies: typing.Optional[commons_signals.SignalDependencies] = None
+    ) -> bool:
         return await signals.edit_order(
             self.exchange_manager, self.should_emit_trading_signal(), order,
             edited_quantity=edited_quantity,
             edited_price=edited_price,
             edited_stop_price=edited_stop_price,
             edited_current_price=edited_current_price,
-            params=params
+            params=params,
+            dependencies=dependencies
         )
 
     async def set_leverage(
-        self, symbol: str, side: typing.Optional[enums.PositionSide], leverage: decimal.Decimal
+        self, symbol: str, side: typing.Optional[enums.PositionSide], leverage: decimal.Decimal,
+        dependencies: typing.Optional[commons_signals.SignalDependencies] = None
     ) -> bool:
         return await signals.set_leverage(
-            self.exchange_manager, self.should_emit_trading_signal(), symbol, side, leverage
+            self.exchange_manager, self.should_emit_trading_signal(), symbol, side, leverage, dependencies=dependencies
         )
 
     async def get_additional_metadata(self, is_backtesting):

{OctoBot-Trading-2.4.210 → OctoBot-Trading-2.4.211}/octobot_trading/modes/channel/abstract_mode_consumer.py

@@ -15,7 +15,9 @@
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library.
 import asyncio
+import typing
 
+import octobot_commons.signals as commons_signals
 import octobot_commons.symbols as symbol_util
 import octobot_commons.constants as commons_constants
 
@@ -30,6 +32,9 @@ from octobot_trading.enums import ExchangeConstantsMarketStatusColumns as Ecmsc
 
 
 class AbstractTradingModeConsumer(modes_channel.ModeChannelConsumer):
+    CREATE_ORDER_DATA_PARAM = "data"
+    CREATE_ORDER_DEPENDENCIES_PARAM = "dependencies"
+    
     def __init__(self, trading_mode):
         super().__init__()
         self.trading_mode = trading_mode
@@ -56,10 +61,15 @@ class AbstractTradingModeConsumer(modes_channel.ModeChannelConsumer):
         self.exchange_manager = None
         self.previous_call_error_per_symbol = None
 
-    async def internal_callback(self, trading_mode_name, cryptocurrency, symbol, time_frame, final_note, state, data):
+    async def internal_callback(
+        self, trading_mode_name, cryptocurrency, symbol, time_frame, final_note, state, 
+        data, dependencies: typing.Optional[commons_signals.SignalDependencies] = None
+    ):
         # creates a new order (or multiple split orders), always check self.can_create_order() first.
         try:
-            await self.create_order_if_possible(symbol, final_note, state, data=data)
+            await self.create_order_if_possible(
+                symbol, final_note, state, data=data, dependencies=dependencies
+            )
             self.previous_call_error_per_symbol[symbol] = None
         except errors.MissingMinimalExchangeTradeVolume as err:
             self.previous_call_error_per_symbol[symbol] = err

{OctoBot-Trading-2.4.210 → OctoBot-Trading-2.4.211}/octobot_trading/modes/channel/abstract_mode_producer.py

@@ -27,6 +27,7 @@ import octobot_commons.logging as logging
 import octobot_commons.databases as databases
 import octobot_commons.configuration as commons_configuration
 import octobot_commons.asyncio_tools as asyncio_tools
+import octobot_commons.signals as commons_signals
 
 import octobot_trading.enums as enums
 import octobot_trading.constants as constants
@@ -400,17 +401,21 @@ class AbstractTradingModeProducer(modes_channel.ModeChannelProducer):
         """
         raise NotImplementedError("set_final_eval not implemented")
 
-    async def submit_trading_evaluation(self, cryptocurrency, symbol, time_frame,
-                                        final_note=constants.ZERO,
-                                        state=enums.EvaluatorStates.NEUTRAL,
-                                        data=None) -> None:
+    async def submit_trading_evaluation(
+        self, cryptocurrency, symbol, time_frame,
+        final_note=constants.ZERO,
+        state=enums.EvaluatorStates.NEUTRAL,
+        data=None,
+        dependencies: typing.Optional[commons_signals.SignalDependencies] = None
+    ) -> None:
         await self.send(trading_mode_name=self.trading_mode.get_name(),
                         cryptocurrency=cryptocurrency,
                         symbol=symbol,
                         time_frame=time_frame,
                         final_note=final_note,
                         state=state.value,
-                        data=data if data is not None else {})
+                        data=data if data is not None else {},
+                        dependencies=dependencies)
 
     @classmethod
     def get_should_cancel_loaded_orders(cls) -> bool:
@@ -420,13 +425,17 @@ class AbstractTradingModeProducer(modes_channel.ModeChannelProducer):
         """
         raise NotImplementedError("get_should_cancel_loaded_orders not implemented")
 
-    async def cancel_symbol_open_orders(self, symbol, side=None, tag=None, exchange_order_ids=None) -> bool:
+    async def cancel_symbol_open_orders(
+        self, symbol, side=None, tag=None, exchange_order_ids=None,
+        dependencies: typing.Optional[commons_signals.SignalDependencies] = None
+    ) -> tuple[bool, commons_signals.SignalDependencies]:
         """
         Cancel all symbol open orders
         """
         cancel_loaded_orders = self.get_should_cancel_loaded_orders()
         cancelled = False
         failed_to_cancel = False
+        cancelled_dependencies = commons_signals.SignalDependencies()
         if self.exchange_manager.trader.is_enabled:
             for order in self.exchange_manager.exchange_personal_data.orders_manager.get_open_orders(
                 symbol=symbol, tag=tag
@@ -438,15 +447,19 @@ class AbstractTradingModeProducer(modes_channel.ModeChannelProducer):
                     and (exchange_order_ids is None or (order.exchange_order_id in exchange_order_ids))
                 ):
                     try:
-                        if await self.trading_mode.cancel_order(order):
+                        is_cancelled, new_dependencies = await self.trading_mode.cancel_order(
+                            order, dependencies=dependencies
+                        )
+                        if is_cancelled:
                             cancelled = True
+                            cancelled_dependencies.extend(new_dependencies)
                         else:
                             failed_to_cancel = True
                     except errors.OctoBotExchangeError as err:
                         # do not propagate exchange error when canceling order
                         self.logger.exception(err, True, f"Error when cancelling order [{order}]: {err}")
                         failed_to_cancel = True
-        return cancelled and not failed_to_cancel
+        return (cancelled and not failed_to_cancel), cancelled_dependencies or None
 
     def all_databases(self):
         provider = databases.RunDatabasesProvider.instance()

{OctoBot-Trading-2.4.210 → OctoBot-Trading-2.4.211}/octobot_trading/modes/channel/mode.py

@@ -14,8 +14,11 @@
 #
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library.
+import typing
+
 import async_channel.constants as channel_constants
 import async_channel.enums as channel_enums
+import octobot_commons.signals as commons_signals
 
 import octobot_trading.exchange_channel as exchanges_channel
 import octobot_trading.constants as constants
@@ -33,7 +36,8 @@ class ModeChannelProducer(exchanges_channel.ExchangeChannelProducer):
                    cryptocurrency=channel_constants.CHANNEL_WILDCARD,
                    symbol=channel_constants.CHANNEL_WILDCARD,
                    time_frame=None,
-                   data=None):
+                   data=None,
+                   dependencies: typing.Optional[commons_signals.SignalDependencies] = None):
         for consumer in self.channel.get_filtered_consumers(trading_mode_name=trading_mode_name,
                                                             state=state,
                                                             cryptocurrency=cryptocurrency,
@@ -46,7 +50,8 @@ class ModeChannelProducer(exchanges_channel.ExchangeChannelProducer):
                 "cryptocurrency": cryptocurrency,
                 "symbol": symbol,
                 "time_frame": time_frame,
-                "data": data
+                "data": data,
+                "dependencies": dependencies
             })