[Orders] add cancel policies

Author: GuillaumeDSM

octobot_trading/enums.py

@@ -570,6 +570,8 @@ class TradingSignalOrdersAttrs(enum.Enum):
     ACTIVE_TRIGGER_PRICE = "active_trigger_price"
     ACTIVE_TRIGGER_ABOVE = "active_trigger_above"
     TRAILING_PROFILE = "trailing_profile"
+    CANCEL_POLICY_TYPE = "cancel_policy_type"
+    CANCEL_POLICY_KWARGS = "cancel_policy_kwargs"
     BUNDLED_WITH = "bundled_with"
     CHAINED_TO = "chained_to"
     ADDITIONAL_ORDERS = "additional_orders"
@@ -614,6 +616,8 @@ class StoredOrdersAttr(enum.Enum):
     ACTIVE_TRIGGER = "at"
     ACTIVE_TRIGGER_PRICE = "atp"
     ACTIVE_TRIGGER_ABOVE = "ata"
+    CANCEL_POLICY = "cp"
+    CANCEL_KWARGS = "cpk"
     TRAILING_PROFILE = "tp"
     TRAILING_PROFILE_TYPE = "tpt"
     TRAILING_PROFILE_DETAILS = "tpd"

octobot_trading/errors.py

@@ -254,6 +254,12 @@ class InvalidOrderState(Exception):
     """
 
 
+class InvalidCancelPolicyError(Exception):
+    """
+    Raised when a cancel policy is invalid
+    """
+
+
 class InvalidLeverageValue(Exception):
     """
     Raised when a leverage is being updated with an invalid value

octobot_trading/exchanges/traders/trader.py

@@ -334,6 +334,7 @@ async def _create_new_order(
             updated_order.associated_entry_ids = new_order.associated_entry_ids
             updated_order.update_with_triggering_order_fees = new_order.update_with_triggering_order_fees
             updated_order.trailing_profile = new_order.trailing_profile
+            updated_order.cancel_policy = new_order.cancel_policy
             if new_order.active_trigger is not None:
                 updated_order.use_active_trigger(order_util.create_order_price_trigger(
                     updated_order, new_order.active_trigger.trigger_price, new_order.active_trigger.trigger_above

octobot_trading/modes/channel/abstract_mode_consumer.py

@@ -89,6 +89,10 @@ async def internal_callback(
             self.logger.info(f"Failed {symbol} order creation on: {self.exchange_manager.exchange_name} "
                              f"an unexpected error happened when creating order. This is likely due to "
                              f"the order being refused by the exchange.")
+        except errors.InvalidCancelPolicyError as err:
+            self.previous_call_error_per_symbol[symbol] = err
+            self.logger.error(f"Invalid cancel policy error on {self.exchange_manager.exchange_name}: {err}. "
+                              f"Please make sure that the provided cancel policy is valid.")
 
     def get_minimal_funds_error(self, symbol, final_note):
         if symbol is None:

octobot_trading/modes/channel/abstract_mode_producer.py

@@ -425,41 +425,77 @@ def get_should_cancel_loaded_orders(cls) -> bool:
         """
         raise NotImplementedError("get_should_cancel_loaded_orders not implemented")
 
+    def _get_to_cancel_orders(
+        self, symbol=None, side=None, tag=None, active=None, exchange_order_ids=None
+    ) -> list:
+        cancel_loaded_orders = self.get_should_cancel_loaded_orders()
+        return [
+            order
+            for order in self.exchange_manager.exchange_personal_data.orders_manager.get_open_orders(
+                symbol=symbol, tag=tag, active=active
+            )
+            if (
+                not (order.is_cancelled() or order.is_closed())
+                and (cancel_loaded_orders or order.is_from_this_octobot)
+                and (side is None or (side is order.side))
+                and (exchange_order_ids is None or (order.exchange_order_id in exchange_order_ids))
+            )
+        ]
+
+    async def _cancel_orders(
+        self, orders: list, 
+        dependencies: typing.Optional[commons_signals.SignalDependencies] = None
+    ) -> tuple[bool, typing.Optional[commons_signals.SignalDependencies]]:
+        cancelled = False
+        failed_to_cancel = False
+        cancelled_dependencies = commons_signals.SignalDependencies()
+        for order in orders:
+            try:
+                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), cancelled_dependencies or None
+
     async def cancel_symbol_open_orders(
-        self, symbol, side=None, tag=None, exchange_order_ids=None,
+        self, symbol, side=None, tag=None, active=None, exchange_order_ids=None,
         dependencies: typing.Optional[commons_signals.SignalDependencies] = None
-    ) -> tuple[bool, commons_signals.SignalDependencies]:
+    ) -> tuple[bool, typing.Optional[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
+            return await self._cancel_orders(
+                self._get_to_cancel_orders(
+                    symbol=symbol, side=side, tag=tag, active=active, exchange_order_ids=exchange_order_ids
+                ), dependencies
+            )
+        return False, None
+
+    async def apply_cancel_policies(
+        self, symbol=None, side=None, tag=None, exchange_order_ids=None, active=None,
+        dependencies: typing.Optional[commons_signals.SignalDependencies] = None
+    ) -> tuple[bool, typing.Optional[commons_signals.SignalDependencies]]:
+        """
+        Cancel all orders that should be according to their cancel policies
+        """
+        if self.exchange_manager.trader.is_enabled:
+            if to_cancel_orders := self.exchange_manager.exchange_personal_data.orders_manager.get_orders_to_cancel_from_policies(
+                self._get_to_cancel_orders(
+                    symbol=symbol, side=side, tag=tag, active=active, exchange_order_ids=exchange_order_ids
+                )
             ):
-                if (
-                    not (order.is_cancelled() or order.is_closed())
-                    and (cancel_loaded_orders or order.is_from_this_octobot)
-                    and (side is None or (side is order.side))
-                    and (exchange_order_ids is None or (order.exchange_order_id in exchange_order_ids))
-                ):
-                    try:
-                        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), cancelled_dependencies or None
+                self.logger.info(f"Cancelling {len(to_cancel_orders)} orders from cancel policies")
+                return await self._cancel_orders(to_cancel_orders, dependencies)
+        return False, None
 
     def all_databases(self):
         provider = databases.RunDatabasesProvider.instance()

octobot_trading/personal_data/__init__.py

@@ -135,6 +135,10 @@
     TakeProfitLimitOrder,
     TrailingStopOrder,
     TrailingStopLimitOrder,
+    create_cancel_policy,
+    OrderCancelPolicy,
+    ExpirationTimeOrderCancelPolicy,
+    ChainedOrderFillingPriceOrderCancelPolicy,
 )
 from octobot_trading.personal_data import portfolios
 from octobot_trading.personal_data.portfolios import (
@@ -478,4 +482,8 @@
     "create_transfer_transaction",
     "SubPortfolioData",
     "ResolvedOrdersPortoflioDelta",
+    "create_cancel_policy",
+    "OrderCancelPolicy",
+    "ExpirationTimeOrderCancelPolicy",
+    "ChainedOrderFillingPriceOrderCancelPolicy",
 ]

octobot_trading/personal_data/orders/__init__.py

@@ -45,6 +45,13 @@
     StopFirstActiveOrderSwapStrategy,
     TakeProfitFirstActiveOrderSwapStrategy,
 )
+from octobot_trading.personal_data.orders import cancel_policies
+from octobot_trading.personal_data.orders.cancel_policies import (
+    create_cancel_policy,
+    OrderCancelPolicy,
+    ExpirationTimeOrderCancelPolicy,
+    ChainedOrderFillingPriceOrderCancelPolicy,
+)
 from octobot_trading.personal_data.orders import triggers
 from octobot_trading.personal_data.orders.triggers import (
     BaseTrigger,
@@ -208,6 +215,7 @@
     "is_stop_trade_order_type",
     "is_take_profit_order",
     "ensure_orders_limit",
+    "create_cancel_policy",
     "create_as_chained_order",
     "ensure_orders_relevancy",
     "get_order_quantity_currency",
@@ -234,6 +242,9 @@
     "ActiveOrderSwapStrategy",
     "StopFirstActiveOrderSwapStrategy",
     "TakeProfitFirstActiveOrderSwapStrategy",
+    "OrderCancelPolicy",
+    "ExpirationTimeOrderCancelPolicy",
+    "ChainedOrderFillingPriceOrderCancelPolicy",
     "BaseTrigger",
     "PriceTrigger",
     "OrdersUpdater",

octobot_trading/personal_data/orders/cancel_policies/__init__.py

@@ -0,0 +1,42 @@
+#  Drakkar-Software OctoBot-Trading
+#  Copyright (c) Drakkar-Software, All rights reserved.
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 3.0 of the License, or (at your option) any later version.
+#
+#  This library is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with this library.
+
+from octobot_trading.personal_data.orders.cancel_policies import cancel_policy_factory
+from octobot_trading.personal_data.orders.cancel_policies.cancel_policy_factory import (
+    create_cancel_policy,
+)
+
+from octobot_trading.personal_data.orders.cancel_policies import order_cancel_policy
+from octobot_trading.personal_data.orders.cancel_policies.order_cancel_policy import (
+    OrderCancelPolicy,
+)
+
+from octobot_trading.personal_data.orders.cancel_policies import expiration_time_order_cancel_policy
+from octobot_trading.personal_data.orders.cancel_policies.expiration_time_order_cancel_policy import (
+    ExpirationTimeOrderCancelPolicy,
+)
+
+from octobot_trading.personal_data.orders.cancel_policies import chained_order_filling_price_order_cancel_policy
+from octobot_trading.personal_data.orders.cancel_policies.chained_order_filling_price_order_cancel_policy import (
+    ChainedOrderFillingPriceOrderCancelPolicy,
+)
+
+__all__ = [
+    "create_cancel_policy",
+    "OrderCancelPolicy",
+    "ExpirationTimeOrderCancelPolicy",
+    "ChainedOrderFillingPriceOrderCancelPolicy",
+]

octobot_trading/personal_data/orders/cancel_policies/cancel_policy_factory.py

@@ -0,0 +1,43 @@
+#  Drakkar-Software OctoBot-Trading
+#  Copyright (c) Drakkar-Software, All rights reserved.
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 3.0 of the License, or (at your option) any later version.
+#
+#  This library is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with this library.
+import typing
+import octobot_trading.personal_data.orders.cancel_policies.order_cancel_policy as order_cancel_policy_import
+import octobot_trading.personal_data.orders.cancel_policies.expiration_time_order_cancel_policy as expiration_time_order_cancel_policy_import
+import octobot_trading.personal_data.orders.cancel_policies.chained_order_filling_price_order_cancel_policy as chained_order_filling_price_order_cancel_policy_import
+import octobot_trading.errors as errors
+
+
+
+def create_cancel_policy(
+    policy_class_name: str,
+    kwargs: typing.Optional[dict] = None
+) -> order_cancel_policy_import.OrderCancelPolicy:
+    """
+    Create a cancel policy instance from its class name and kwargs.
+    
+    :param policy_class_name: The name of the cancel policy class
+    :param kwargs: Optional dictionary of keyword arguments to pass to the policy constructor
+    :return: An instance of the cancel policy, or None if the class name is not recognized
+    """
+    kwargs = kwargs or {}
+    try:
+        if policy_class_name == expiration_time_order_cancel_policy_import.ExpirationTimeOrderCancelPolicy.__name__:
+            return expiration_time_order_cancel_policy_import.ExpirationTimeOrderCancelPolicy(**kwargs)
+        elif policy_class_name == chained_order_filling_price_order_cancel_policy_import.ChainedOrderFillingPriceOrderCancelPolicy.__name__:
+            return chained_order_filling_price_order_cancel_policy_import.ChainedOrderFillingPriceOrderCancelPolicy(**kwargs)
+    except TypeError as err:
+        raise errors.InvalidCancelPolicyError(f"Invalid kwargs for {policy_class_name}: {err}") from err
+    raise NotImplementedError(f"Unsupported cancel policy class name: {policy_class_name}")

octobot_trading/personal_data/orders/cancel_policies/chained_order_filling_price_order_cancel_policy.py

@@ -0,0 +1,54 @@
+#  Drakkar-Software OctoBot-Trading
+#  Copyright (c) Drakkar-Software, All rights reserved.
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 3.0 of the License, or (at your option) any later version.
+#
+#  This library is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with this library.
+import dataclasses
+import octobot_trading.personal_data.orders.order_util as order_util
+import octobot_trading.personal_data.orders.cancel_policies.order_cancel_policy as order_cancel_policy_import
+
+
+@dataclasses.dataclass
+class ChainedOrderFillingPriceOrderCancelPolicy(order_cancel_policy_import.OrderCancelPolicy):
+    """
+    Will cancel the order if at least one of the chained orders filling price is reached.
+    """
+
+    def should_cancel(self, order) -> bool:
+        if order.is_cleared():
+            self.get_logger().error(
+                f"Ignored cancel policy: order {str(order)} has been cleared"
+            )
+            return False
+        if not order.chained_orders:
+            self.get_logger().error(
+                f"Ignored cancel policy: order {str(order)} has no chained orders"
+            )
+            return False
+        current_price, up_to_date = order_util.get_potentially_outdated_price(
+            order.trader.exchange_manager, order.symbol
+        )
+        if not up_to_date:
+            self.get_logger().error(
+                f"Ignored cancel policy: order {str(order)} mark price: {current_price} is outdated"
+            )
+            return False
+        for chained_order in order.chained_orders:
+            if chained_order.trigger_above and current_price > chained_order.get_filling_price():
+                # this chained order price is reached
+                return True
+            if not chained_order.trigger_above and current_price < chained_order.get_filling_price():
+                # this chained order price is reached
+                return True
+        # no chained order price is reached
+        return False