[Orders] extract active trigger in trigger class

Author: GuillaumeDSM

octobot_trading/enums.py

@@ -637,3 +637,4 @@ class TradingModeActivityType(enum.Enum):
 
 class ActiveOrderSwapTriggerPriceConfiguration(enum.Enum):
     FILLING_PRICE = "filling_price"
+    ORDER_PARAMS_ONLY = "order_params_only"

octobot_trading/exchanges/traders/trader.py

@@ -318,8 +318,10 @@ 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.active_trigger_price = new_order.active_trigger_price
-            updated_order.active_trigger_above = new_order.active_trigger_above
+            if new_order.active_trigger is not None:
+                updated_order.create_or_update_active_trigger(
+                    new_order.active_trigger.trigger_price, new_order.active_trigger.trigger_above
+                )
             updated_order.is_in_active_inactive_transition = new_order.is_in_active_inactive_transition
 
             if is_pending_creation:
@@ -405,8 +407,8 @@ async def update_order_as_inactive(
         self, order, ignored_order=None, wait_for_cancelling=True,
         cancelling_timeout=octobot_trading.constants.INDIVIDUAL_ORDER_SYNC_TIMEOUT
     ) -> bool:
-        if self.simulate:
-            self.logger.error(f"Can't update order as inactive on simulated trading.")
+        if not self.enable_inactive_orders:
+            self.logger.error(f"Can't update order as inactive when {self.enable_inactive_orders=}.")
             return False
         cancelled = False
         if order and order.is_open():
@@ -422,8 +424,8 @@ 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
     ):
-        if self.simulate:
-            self.logger.error(f"Can't update order as active on simulated trading.")
+        if not self.enable_inactive_orders:
+            self.logger.error(f"Can't update order as active when {self.enable_inactive_orders=}.")
             return order
         with order.active_or_inactive_transition():
             return await self.create_order(

octobot_trading/personal_data/exchange_personal_data.py

@@ -299,7 +299,7 @@ async def check_and_update_inactive_orders_when_necessary(
         self, symbol: str, current_price: decimal.Decimal, price_time: float,
         strategy_timeout: typing.Optional[float], wait_for_fill_callback: typing.Optional[typing.Callable]
     ):
-        for order in self.orders_manager.get_inactive_orders(symbol=symbol):
+        for order in self.orders_manager.get_all_orders(symbol=symbol, active=False):
             if order.should_become_active(price_time, current_price):
                 try:
                     await order.on_active_trigger(strategy_timeout, wait_for_fill_callback)

octobot_trading/personal_data/orders/active_order_swap_strategies/active_order_swap_strategy.py

@@ -47,6 +47,13 @@ async def apply_inactive_orders(self, orders: list):
     def _get_trigger_price(self, order) -> decimal.Decimal:
         if self.trigger_price_configuration == enums.ActiveOrderSwapTriggerPriceConfiguration.FILLING_PRICE.value:
             return order.get_filling_price()
+        if self.trigger_price_configuration == enums.ActiveOrderSwapTriggerPriceConfiguration.ORDER_PARAMS_ONLY.value:
+            if order.active_trigger is None or order.active_trigger.trigger_price is None:
+                raise ValueError(
+                    f"order.active_trigger.trigger_price must be set when using "
+                    f"ActiveOrderSwapTriggerPriceConfiguration.ORDER_PARAMS_ONLY. Order: {order}"
+                )
+            return order.active_trigger.trigger_price
         raise ValueError(f"Unknown trigger price configuration: {self.trigger_price_configuration}")
 
     async def execute(self, inactive_order, wait_for_fill_callback: typing.Optional[typing.Callable]):

octobot_trading/personal_data/orders/channel/orders.py

@@ -234,9 +234,9 @@ async def _check_missing_open_orders(self, symbol, orders):
             set(
                 order.exchange_order_id for order in
                 self.channel.exchange_manager.exchange_personal_data.orders_manager.get_open_orders(
-                    symbol
+                    symbol, active=True
                 ) + self.channel.exchange_manager.exchange_personal_data.orders_manager.get_pending_cancel_orders(
-                    symbol
+                    symbol, active=True
                 )
                 if not (order.is_cleared() or order.is_self_managed())) -
             set(

octobot_trading/personal_data/orders/order.py

@@ -28,6 +28,7 @@
 import octobot_trading.personal_data.orders.order_util as order_util
 import octobot_trading.personal_data.orders.trailing_profiles as trailing_profiles
 import octobot_trading.personal_data.orders.decimal_order_adapter as decimal_order_adapter
+import octobot_trading.personal_data.orders.triggers.price_trigger as price_trigger
 import octobot_trading.util as util
 
 
@@ -97,14 +98,9 @@ def __init__(self, trader, side=None):
 
         # order activity
         self.is_active = True   # When is_active=False order is not pushed to exchanges
-        self.active_trigger_price: decimal.Decimal = None    # price threshold from which the order becomes active
-        # when True, order becomes active when current price >= active_trigger_price
-        self.active_trigger_above: bool = None
-        self._active_trigger_event: asyncio.Event = None    # will be set when the price is hit
-        # waiter that will call on_active_trigger() when active_trigger_event is set
-        self._active_trigger_task: asyncio.Task = None
         # True when a transition between active and inactive is being made
         self.is_in_active_inactive_transition = False
+        self.active_trigger: typing.Optional[price_trigger.PriceTrigger] = None
 
         # future trading attributes
         # when True: reduce position quantity only without opening a new position if order.quantity > position.quantity
@@ -304,13 +300,17 @@ def update(
             changed = True
             self.is_active = is_active
 
-        if active_trigger_price is not None and self.active_trigger_price != active_trigger_price:
+        if (active_trigger_price is not None or active_trigger_above is not None) and self.active_trigger is None:
             changed = True
-            self.active_trigger_price = active_trigger_price
+            self.create_or_update_active_trigger(active_trigger_price, active_trigger_above)
 
-        if active_trigger_above is not None and self.active_trigger_above != active_trigger_above:
+        if active_trigger_price is not None and self.active_trigger.trigger_price != active_trigger_price:
             changed = True
-            self.active_trigger_above = active_trigger_above
+            self.active_trigger.trigger_price = active_trigger_price
+
+        if active_trigger_above is not None and self.active_trigger.trigger_above != active_trigger_above:
+            changed = True
+            self.active_trigger.trigger_above = active_trigger_above
 
         if should_update_total_cost and not total_cost:
             self._update_total_cost()
@@ -435,6 +435,15 @@ def active_or_inactive_transition(self):
         finally:
             self.is_in_active_inactive_transition = previous_value
 
+    def create_or_update_active_trigger(self, active_trigger_price: decimal.Decimal, active_trigger_above: bool):
+        if self.active_trigger is None:
+            self.active_trigger = price_trigger.PriceTrigger(
+                self.on_active_trigger, (None, None), active_trigger_price, active_trigger_above
+            )
+        else:
+            self.active_trigger.trigger_price = active_trigger_price
+            self.active_trigger.trigger_above = active_trigger_above
+
     async def set_as_inactive(self, active_trigger_price: decimal.Decimal, active_trigger_above: bool):
         """
         Marks the instance as inactive and ensures the inactive order watcher is scheduled.
@@ -445,8 +454,7 @@ async def set_as_inactive(self, active_trigger_price: decimal.Decimal, active_tr
             )
         logging.get_logger(self.get_logger_name()).info("Order is switching to inactive")
         self.is_active = False
-        self.active_trigger_price = active_trigger_price
-        self.active_trigger_above = active_trigger_above
+        self.create_or_update_active_trigger(active_trigger_price, active_trigger_above)
         # enforce attributes in case order has been canceled
         self.status = enums.OrderStatus.OPEN
         self.canceled_time = 0
@@ -456,12 +464,7 @@ def should_become_active(self, price_time: float, current_price: decimal.Decimal
         if self.is_active:
             return False
         if price_time >= self.creation_time:
-            return (
-                (self.active_trigger_above and current_price >= self.active_trigger_price)
-                or (
-                    not self.active_trigger_above and current_price <= self.active_trigger_price
-                )
-            )
+            return self.active_trigger.triggers(current_price)
         return False
 
     async def _ensure_inactive_order_watcher(self):
@@ -474,40 +477,10 @@ async def _ensure_inactive_order_watcher(self):
                 f"Unexpected inactive order (simulated={self.simulated} self_managed={self.is_self_managed()}): {self}"
             )
             return
-        await self._create_active_trigger_watcher()
-
-    async def _create_active_trigger_watcher(self):
-        # ensure active triggers are ready
-        if self._active_trigger_event is None:
-            self._create_active_trigger_event(self.creation_time)
-        else:
-            self._active_trigger_event.clear()
-        if self._active_trigger_task is None or self._active_trigger_task.done():
-            if self._active_trigger_event.is_set():
-                await self.on_active_trigger(None, None)
-            else:
-                self._create_active_trigger_task()
-
-    def _create_active_trigger_event(self, price_time):
-        self._active_trigger_event = self.exchange_manager.exchange_symbols_data.\
-            get_exchange_symbol_data(self.symbol).price_events_manager.\
-            new_event(self.active_trigger_price, price_time, self.active_trigger_above, False)
-
-    async def _wait_for_active_trigger_set(self):
-        await asyncio.wait_for(self._active_trigger_event.wait(), timeout=None)
-        await self.on_active_trigger(None, None)
-
-    def _create_active_trigger_task(self):
-        self._active_trigger_task = asyncio.create_task(self._wait_for_active_trigger_set())
-
-    def _clear_active_trigger_event_and_tasks(self):
-        if self._active_trigger_task is not None:
-            if not self._active_trigger_event.is_set():
-                self._active_trigger_task.cancel()
-            self._active_trigger_task = None
-        if self._active_trigger_event is not None:
-            self.exchange_manager.exchange_symbols_data. \
-                get_exchange_symbol_data(self.symbol).price_events_manager.remove_event(self._active_trigger_event)
+        if self.active_trigger is None:
+            logging.get_logger(self.get_logger_name()).error("self.active_trigger is None")
+            return
+        await self.active_trigger.create_watcher(self.exchange_manager, self.symbol, self.creation_time)
 
     @contextlib.contextmanager
     def order_state_creation(self):
@@ -520,7 +493,11 @@ async def on_inactive_from_active(self):
         """
         Update the order to be considered as "confirmed" inactive. Called when the order was active before
         """
-        await self.set_as_inactive(self.active_trigger_price, self.active_trigger_above)
+        if self.active_trigger is None:
+            raise ValueError(
+                f"Both active_trigger_price and active_trigger_above must be provided to set an order as inactive"
+            )
+        await self.set_as_inactive(self.active_trigger.trigger_price, self.active_trigger.trigger_above)
         self.clear_active_order_elements()
 
     async def on_active_from_inactive(self):
@@ -941,13 +918,13 @@ def update_from_storage_order_details(self, order_details):
             order_dict[enums.ExchangeConstantsOrderColumns.TAKER_OR_MAKER.value]
         ).value if order_dict.get(enums.ExchangeConstantsOrderColumns.TAKER_OR_MAKER.value) else self.taker_or_maker
         self.is_active = order_dict.get(enums.ExchangeConstantsOrderColumns.IS_ACTIVE.value, self.is_active)
-        self.active_trigger_price = (
+        active_trigger_price = (
             decimal.Decimal(str(order_dict[enums.ExchangeConstantsOrderColumns.ACTIVE_TRIGGER_PRICE.value]))
             if order_dict.get(enums.ExchangeConstantsOrderColumns.ACTIVE_TRIGGER_PRICE.value) else None
         )
-        self.active_trigger_above = order_dict.get(
-            enums.ExchangeConstantsOrderColumns.ACTIVE_TRIGGER_ABOVE.value, self.active_trigger_above
-        )
+        active_trigger_above = order_dict.get(enums.ExchangeConstantsOrderColumns.ACTIVE_TRIGGER_ABOVE.value)
+        if active_trigger_price is not None:
+            self.create_or_update_active_trigger(active_trigger_price, active_trigger_above)
         self.trader_creation_kwargs = order_details.get(enums.StoredOrdersAttr.TRADER_CREATION_KWARGS.value,
                                                         self.trader_creation_kwargs)
         self.exchange_creation_params = order_details.get(enums.StoredOrdersAttr.EXCHANGE_CREATION_PARAMS.value,
@@ -1080,7 +1057,8 @@ def clear_active_order_elements(self):
 
 
     def clear(self):
-        self._clear_active_trigger_event_and_tasks()
+        if self.active_trigger:
+            self.active_trigger.clear()
         self.clear_active_order_elements()
         self.trader = None
         self.exchange_manager = None

octobot_trading/personal_data/orders/order_group.py

@@ -71,6 +71,7 @@ def _default_active_order_swap_strategy(self, timeout: float) -> active_order_sw
         """
         Called when an order of this group is becoming active
         """
+        raise NotImplementedError("_default_active_order_swap_strategy is not implemented")
 
 
     async def enable(self, enabled):

octobot_trading/personal_data/orders/orders_manager.py

@@ -53,26 +53,28 @@ async def initialize_impl(self):
 
     def get_all_orders(
         self, symbol=None, since=constants.NO_DATA_LIMIT, 
-        until=constants.NO_DATA_LIMIT, limit=constants.NO_DATA_LIMIT, tag=None):
+        until=constants.NO_DATA_LIMIT, limit=constants.NO_DATA_LIMIT,
+        tag=None, active=None):
         return self._select_orders(
             None, symbol=symbol, since=since,
-            until=until, limit=limit, tag=tag
+            until=until, limit=limit, tag=tag, active=active
         )
 
     def get_open_orders(
         self, symbol=None, since=constants.NO_DATA_LIMIT, until=constants.NO_DATA_LIMIT,
-        limit=constants.NO_DATA_LIMIT, tag=None):
+        limit=constants.NO_DATA_LIMIT, tag=None, active=None
+    ):
         return self._select_orders(
             enums.OrderStatus.OPEN, symbol, since=since,
-            until=until, limit=limit, tag=tag
+            until=until, limit=limit, tag=tag, active=active
         )
 
     def get_pending_cancel_orders(
         self, symbol=None, since=constants.NO_DATA_LIMIT, until=constants.NO_DATA_LIMIT,
-        limit=constants.NO_DATA_LIMIT, tag=None):
+        limit=constants.NO_DATA_LIMIT, tag=None, active=None):
         return self._select_orders(
             enums.OrderStatus.PENDING_CANCEL, symbol, since=since, 
-            until=until, limit=limit, tag=tag
+            until=until, limit=limit, tag=tag, active=active
         )
 
     def get_closed_orders(
@@ -184,13 +186,6 @@ def get_all_active_and_pending_orders_id(self) -> list:
             for order in self.pending_creation_orders
         ]
 
-    def get_inactive_orders(self, symbol=None) -> list:
-        return [
-            order
-            for order in self._select_orders(symbol=symbol)
-            if not order.is_active
-        ]
-
     async def upsert_order_close_from_raw(self, exchange_order_id, raw_order) -> typing.Optional[order_class.Order]:
         if self.has_order(None, exchange_order_id=exchange_order_id):
             order = self.get_order(None, exchange_order_id=exchange_order_id)
@@ -266,7 +261,9 @@ def _check_orders_size(self):
 
     def _select_orders(
         self, state=None, symbol=None, since=constants.NO_DATA_LIMIT, 
-        until=constants.NO_DATA_LIMIT, limit=constants.NO_DATA_LIMIT, tag=None):
+        until=constants.NO_DATA_LIMIT, limit=constants.NO_DATA_LIMIT,
+        tag=None, active=None
+    ):
         orders = [
             order
             for order in self.orders.values()
@@ -275,7 +272,8 @@ def _select_orders(
                 (symbol is None or (symbol and order.symbol == symbol)) and
                 (since == constants.NO_DATA_LIMIT or (since and order.timestamp >= since)) and
                 (until == constants.NO_DATA_LIMIT or (until and order.timestamp <= until)) and
-                (tag is None or order.tag == tag)
+                (tag is None or order.tag == tag) and
+                (active is None or order.is_active == active)
             )
         ]
         return orders if limit == constants.NO_DATA_LIMIT else orders[0:limit]

octobot_trading/personal_data/orders/triggers/__init__.py

@@ -0,0 +1,32 @@
+#  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.triggers import base_trigger
+from octobot_trading.personal_data.orders.triggers.base_trigger import (
+    BaseTrigger,
+)
+
+
+from octobot_trading.personal_data.orders.triggers import price_trigger
+from octobot_trading.personal_data.orders.triggers.price_trigger import (
+    PriceTrigger,
+)
+
+__all__ = [
+    "BaseTrigger",
+    "PriceTrigger",
+]