[Orders] extract active trigger in trigger class

Author: GuillaumeDSM

octobot_trading/enums.py

@@ -335,8 +335,6 @@ class ExchangeConstantsOrderColumns(enum.Enum):
     VOLUME = "volume"
     BROKER_APPLIED = "broker_applied"
     IS_ACTIVE = "is_active"
-    ACTIVE_TRIGGER_PRICE = "active_trigger_price"
-    ACTIVE_TRIGGER_ABOVE = "active_trigger_above"
 
 
 class TradeExtraConstants(enum.Enum):
@@ -601,6 +599,9 @@ class StoredOrdersAttr(enum.Enum):
     STRATEGY_TIMEOUT = "sti"
     STRATEGY_TRIGGER_CONFIG = "stc"
     CHAINED_ORDERS = "co"
+    ACTIVE_TRIGGER = "at"
+    ACTIVE_TRIGGER_PRICE = "atp"
+    ACTIVE_TRIGGER_ABOVE = "ata"
     TRAILING_PROFILE = "tp"
     TRAILING_PROFILE_TYPE = "tpt"
     TRAILING_PROFILE_DETAILS = "tpd"
@@ -637,3 +638,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.use_active_trigger(order_util.create_order_price_trigger(
+                    updated_order, 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/__init__.py

@@ -58,6 +58,7 @@
     is_associated_pending_order,
     apply_pending_order_from_created_order,
     get_up_to_date_price,
+    create_order_price_trigger,
     create_as_active_order_using_strategy_if_any,
     create_as_active_order_on_exchange,
     update_order_as_inactive_on_exchange,
@@ -301,6 +302,7 @@
     "is_associated_pending_order",
     "apply_pending_order_from_created_order",
     "get_up_to_date_price",
+    "create_order_price_trigger",
     "create_as_active_order_using_strategy_if_any",
     "create_as_active_order_on_exchange",
     "update_order_as_inactive_on_exchange",

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/__init__.py

@@ -115,6 +115,7 @@
     is_stop_trade_order_type,
     is_take_profit_order,
     get_trade_order_type,
+    create_order_price_trigger,
     create_as_active_order_using_strategy_if_any,
     create_as_active_order_on_exchange,
     update_order_as_inactive_on_exchange,
@@ -188,6 +189,7 @@
     "parse_is_pending_cancel",
     "parse_is_open",
     "get_up_to_date_price",
+    "create_order_price_trigger",
     "create_as_active_order_using_strategy_if_any",
     "create_as_active_order_on_exchange",
     "update_order_as_inactive_on_exchange",

octobot_trading/personal_data/orders/active_order_swap_strategies/active_order_swap_strategy.py

@@ -39,14 +39,25 @@ async def apply_inactive_orders(self, orders: list):
         for order in orders:
             trigger_price = self._get_trigger_price(order)
             if self.is_priority_order(order):
-                # still register active trigger price and trigger above in case this order becomes inactive
-                order.update(active_trigger_price=trigger_price, active_trigger_above=order.trigger_above)
+                # still register active trigger in case this order becomes inactive
+                order.update(
+                    active_trigger=order_util.create_order_price_trigger(order, trigger_price, order.trigger_above)
+                )
             else:
-                await order.set_as_inactive(trigger_price, order.trigger_above)
+                await order.set_as_inactive(
+                    order_util.create_order_price_trigger(order, trigger_price, order.trigger_above)
+                )
 
     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]):
@@ -57,6 +68,8 @@ async def execute(self, inactive_order, wait_for_fill_callback: typing.Optional[
             active_order, now_maybe_partially_inactive_orders, reverse_update_callback = (
                 await self._update_group_and_activate_order(inactive_order)
             )
+            if active_order is None:
+                raise ValueError("No active order was created")
             if not any(self.is_priority_order(inactive_order) for inactive_order in now_maybe_partially_inactive_orders):
                 # nothing else to do: no priority order has been deactivated
                 return

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,10 @@ 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
+        # active_trigger is used for active/inactive switch trigger mechanism, it stores relevant data.
+        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
@@ -154,7 +151,7 @@ def update(
         order_type=None, reduce_only=None, close_position=None, position_side=None, fees_currency_side=None,
         group=None, tag=None, quantity_currency=None, exchange_creation_params=None,
         associated_entry_id=None, trigger_above=None, trailing_profile: trailing_profiles.TrailingProfile=None,
-        is_active=None, active_trigger_price=None, active_trigger_above=None
+        is_active=None, active_trigger: price_trigger.PriceTrigger = None,
     ) -> bool:
         changed: bool = False
         should_update_total_cost = False
@@ -304,13 +301,9 @@ 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 is not None and active_trigger != self.active_trigger:
             changed = True
-            self.active_trigger_price = active_trigger_price
-
-        if active_trigger_above is not None and self.active_trigger_above != active_trigger_above:
-            changed = True
-            self.active_trigger_above = active_trigger_above
+            self.use_active_trigger(active_trigger)
 
         if should_update_total_cost and not total_cost:
             self._update_total_cost()
@@ -435,18 +428,29 @@ def active_or_inactive_transition(self):
         finally:
             self.is_in_active_inactive_transition = previous_value
 
-    async def set_as_inactive(self, active_trigger_price: decimal.Decimal, active_trigger_above: bool):
+    def use_active_trigger(self, active_trigger: price_trigger.PriceTrigger):
+        if active_trigger is None:
+            raise ValueError("active_trigger must be provided")
+        if self.active_trigger is None:
+            self.active_trigger = active_trigger
+        elif self.active_trigger.is_pending():
+            logging.get_logger(self.get_logger_name()).error(
+                f"The current active trigger (at {self.active_trigger.trigger_price}) is still pending, canceling it "
+                f"and replacing it by this new one, this is works but is unexpected."
+            )
+            self.active_trigger.clear()
+            self.active_trigger = active_trigger
+        else:
+            self.active_trigger.trigger_price = active_trigger.trigger_price
+            self.active_trigger.trigger_above = active_trigger.trigger_above
+
+    async def set_as_inactive(self, active_trigger: price_trigger.PriceTrigger):
         """
         Marks the instance as inactive and ensures the inactive order watcher is scheduled.
         """
-        if active_trigger_price is None or active_trigger_above is None:
-            raise ValueError(
-                f"Both active_trigger_price and active_trigger_above must be provided to set an order as inactive"
-            )
         logging.get_logger(self.get_logger_name()).info("Order is switching to inactive")
+        self.use_active_trigger(active_trigger)
         self.is_active = False
-        self.active_trigger_price = active_trigger_price
-        self.active_trigger_above = active_trigger_above
         # enforce attributes in case order has been canceled
         self.status = enums.OrderStatus.OPEN
         self.canceled_time = 0
@@ -456,12 +460,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 +473,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 +489,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"self.active_trigger must be provided to set an order as inactive"
+            )
+        await self.set_as_inactive(self.active_trigger)
         self.clear_active_order_elements()
 
     async def on_active_from_inactive(self):
@@ -941,13 +914,15 @@ 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 = (
-            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
-        )
+        if active_trigger := order_details.get(enums.StoredOrdersAttr.ACTIVE_TRIGGER.value):
+            active_trigger_price = (
+                decimal.Decimal(str(active_trigger[enums.StoredOrdersAttr.ACTIVE_TRIGGER_PRICE.value]))
+                if active_trigger.get(enums.StoredOrdersAttr.ACTIVE_TRIGGER_PRICE.value) else None
+            )
+            active_trigger_above = active_trigger.get(enums.StoredOrdersAttr.ACTIVE_TRIGGER_ABOVE.value)
+            self.use_active_trigger(
+                order_util.create_order_price_trigger(self, 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 +1055,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_factory.py

@@ -112,8 +112,8 @@ def create_order_instance(
         trigger_above=trigger_above,
         trailing_profile=trailing_profile,
         is_active=is_active,
-        active_trigger_price=active_trigger_price,
-        active_trigger_above=active_trigger_above
+        active_trigger=personal_data.create_order_price_trigger(order, active_trigger_price, active_trigger_above)
+            if active_trigger_price else None,
     )
     return order
 

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/order_util.py

@@ -31,6 +31,7 @@
 import octobot_trading.exchanges.util.exchange_market_status_fixer as exchange_market_status_fixer
 import octobot_trading.personal_data.orders.states.fill_order_state as fill_order_state
 import octobot_trading.personal_data.orders.order as order_import
+import octobot_trading.personal_data.orders.triggers.price_trigger as price_trigger
 import octobot_trading.signals as signals
 from octobot_trading.enums import ExchangeConstantsMarketStatusColumns as Ecmsc
 
@@ -509,6 +510,16 @@ def get_trade_order_type(order_type: enums.TraderOrderType) -> enums.TradeOrderT
     raise ValueError(order_type)
 
 
+def create_order_price_trigger(
+    order: order_import.Order, active_trigger_price: decimal.Decimal, active_trigger_above: bool
+) -> price_trigger.PriceTrigger:
+    if active_trigger_price is None or active_trigger_above is None:
+        raise ValueError("active_trigger_price and active_trigger_above must be specified")
+    return price_trigger.PriceTrigger(
+        order.on_active_trigger, (None, None), active_trigger_price, active_trigger_above
+    )
+
+
 async def create_as_active_order_using_strategy_if_any(
     order, strategy_timeout: typing.Optional[float], wait_for_fill_callback: typing.Optional[typing.Callable]
 ):