[PriceTrigger] synch on updated order price

Author: GuillaumeDSM

octobot_trading/personal_data/orders/active_order_swap_strategies/active_order_swap_strategy.py

@@ -48,6 +48,13 @@ async def apply_inactive_orders(self, orders: list):
                     order_util.create_order_price_trigger(order, trigger_price, order.trigger_above)
                 )
 
+    def on_order_update(self, order, update_time):
+        if order.active_trigger:
+            order.active_trigger.update(
+                trigger_price=self._get_trigger_price(order), min_trigger_time=update_time,
+                update_event=order.is_synchronization_enabled()
+            )
+
     def _get_trigger_price(self, order) -> decimal.Decimal:
         if self.trigger_price_configuration == enums.ActiveOrderSwapTriggerPriceConfiguration.FILLING_PRICE.value:
             return order.get_filling_price()

octobot_trading/personal_data/orders/order.py

@@ -202,8 +202,9 @@ def update(
         if price and self.origin_price != price:
             previous_price = self.origin_price
             self.origin_price = price
-            self._on_origin_price_change(previous_price,
-                                         self.exchange_manager.exchange.get_exchange_current_time())
+            self._on_origin_price_change(
+                previous_price, self.exchange_manager.exchange.get_exchange_current_time()
+            )
             changed = True
             should_update_total_cost = True
 
@@ -342,6 +343,8 @@ def _on_origin_price_change(self, previous_price, price_time):
         :param previous_price: the previous origin_price
         :param price_time: time starting from when the price should be considered
         """
+        if self.order_group and self.order_group.active_order_swap_strategy:
+            self.order_group.active_order_swap_strategy.on_order_update(self, price_time)
 
     def add_chained_order(self, chained_order):
         """

octobot_trading/personal_data/orders/triggers/base_trigger.py

@@ -25,6 +25,9 @@ def __init__(self, on_trigger_callback: typing.Callable, on_trigger_callback_arg
         self._trigger_event: asyncio.Event = None    # will be set when the trigger is hit
         self._trigger_task: asyncio.Task = None
 
+    def triggers(self, *args) -> bool:
+        raise NotImplementedError("triggers is not implemented")
+
     def triggered(self) -> bool:
         return self._trigger_event is not None and self._trigger_event.is_set()
 
@@ -34,6 +37,9 @@ def is_pending(self) -> bool:
     def update_from_other_trigger(self, other_trigger):
         raise NotImplementedError("update_from_other_trigger is not implemented")
 
+    def update(self, **kwargs):
+        raise NotImplementedError("update is not implemented")
+
     def __str__(self):
         return f"{self.__class__.__name__}({self.on_trigger_callback.__name__ if self.on_trigger_callback else None})"
 

octobot_trading/personal_data/orders/triggers/price_trigger.py

@@ -43,19 +43,33 @@ def update_from_other_trigger(self, other_trigger):
         self.trigger_price = other_trigger.trigger_price
         self.trigger_above = other_trigger.trigger_above
 
+    def update(self, trigger_price=None, min_trigger_time=None, update_event=True, **kwargs):
+        if self.trigger_price != trigger_price:
+            self.trigger_price = trigger_price
+            if update_event and self._exchange_manager is not None:
+                # replace event
+                self._clear_event()
+                self._create_event(min_trigger_time)
+
     def clear(self):
         super().clear()
+        self._clear_event()
+        self._exchange_manager = None
+
+    def _create_event(self, min_trigger_time: float):
+        self._trigger_event = self._exchange_manager.exchange_symbols_data.\
+            get_exchange_symbol_data(self._symbol).price_events_manager.\
+            new_event(self.trigger_price, min_trigger_time, self.trigger_above, False)
+
+    def _clear_event(self):
         if self._trigger_event is not None and self._exchange_manager is not None:
             self._exchange_manager.exchange_symbols_data. \
                 get_exchange_symbol_data(self._symbol).price_events_manager.remove_event(self._trigger_event)
-        self._exchange_manager = None
 
     def __str__(self):
         return f"{super().__str__()}: trigger_price={self.trigger_price}, trigger_above={self.trigger_above}"
 
     def _create_trigger_event(self, exchange_manager, symbol: str, min_trigger_time: float):
         self._exchange_manager = exchange_manager
         self._symbol = symbol
-        self._trigger_event = self._exchange_manager.exchange_symbols_data.\
-            get_exchange_symbol_data(self._symbol).price_events_manager.\
-            new_event(self.trigger_price, min_trigger_time, self.trigger_above, False)
+        self._create_event(min_trigger_time)

octobot_trading/personal_data/orders/types/limit/limit_order.py

@@ -75,6 +75,7 @@ async def update_order_status(self, force_refresh=False):
                     self._create_hit_task()
 
     def _on_origin_price_change(self, previous_price, price_time):
+        super()._on_origin_price_change(previous_price, price_time)
         if previous_price is not constants.ZERO:
             # no need to reset events if previous price was 0 (unset)
             self._reset_events(price_time)

tests/personal_data/orders/active_order_swap_strategies/test_active_order_swap_strategy.py

@@ -244,3 +244,43 @@ async def test_execute_with_reverse(swap_strategy, simulated_trader):
             assert stop_loss.is_closed()
             assert len(exchange_manager.exchange_personal_data.orders_manager.get_all_orders()) == 2
             assert len(exchange_manager.exchange_personal_data.orders_manager.get_open_orders()) == 2
+
+
+async def test_on_order_update(swap_strategy):
+    # Setup
+    order = mock.Mock()
+    order.active_trigger = mock.Mock()
+    order.is_synchronization_enabled = mock.Mock(return_value=True)
+    order.get_filling_price = mock.Mock(return_value=decimal.Decimal("100"))
+    update_time = 1234.56
+
+    # Test with default trigger price configuration (FILLING_PRICE)
+    swap_strategy.on_order_update(order, update_time)
+
+    # Verify
+    order.active_trigger.update.assert_called_once_with(
+        trigger_price=decimal.Decimal("100"),
+        min_trigger_time=update_time,
+        update_event=True
+    )
+
+    # Test with no active trigger
+    order.active_trigger = None
+    swap_strategy.on_order_update(order, update_time)
+    # Should not raise any error when there's no active trigger
+
+    # Test with ORDER_PARAMS_ONLY configuration
+    strategy = personal_data.ActiveOrderSwapStrategy(
+        trigger_price_configuration=enums.ActiveOrderSwapTriggerPriceConfiguration.ORDER_PARAMS_ONLY.value
+    )
+    order.active_trigger = mock.Mock()
+    order.active_trigger.trigger_price = decimal.Decimal("150")
+
+    strategy.on_order_update(order, update_time)
+
+    # Verify
+    order.active_trigger.update.assert_called_once_with(
+        trigger_price=decimal.Decimal("150"),
+        min_trigger_time=update_time,
+        update_event=True
+    )

tests/personal_data/orders/triggers/test_price_trigger.py

@@ -77,6 +77,93 @@ def test_update_from_other_trigger(price_trigger):
     # Original callback and args should remain unchanged
     assert price_trigger.on_trigger_callback_args == ("arg1", "arg2")
 
+def test_update(price_trigger):
+    # Setup
+    callback = mock.Mock()
+
+    # Test update without exchange manager (no event creation)
+    new_price = decimal.Decimal("150")
+    price_trigger.update(trigger_price=new_price)
+    assert price_trigger.trigger_price == new_price
+
+    # Setup exchange manager mock
+    price_trigger._exchange_manager = mock.Mock()
+    price_trigger._symbol = "BTC/USD"
+    price_trigger._trigger_event = mock.Mock()
+
+    # Test update with exchange manager and event creation
+    newer_price = decimal.Decimal("200")
+    min_trigger_time = 1234.56
+
+    with mock.patch.object(price_trigger, '_create_event') as mock_create_event, \
+            mock.patch.object(price_trigger, '_clear_event') as mock_clear_event:
+        price_trigger.update(
+            trigger_price=newer_price,
+            min_trigger_time=min_trigger_time,
+            update_event=True
+        )
+
+        assert price_trigger.trigger_price == newer_price
+        mock_clear_event.assert_called_once()
+        mock_create_event.assert_called_once_with(min_trigger_time)
+
+    # Test update without event update
+    newest_price = decimal.Decimal("250")
+    with mock.patch.object(price_trigger, '_create_event') as mock_create_event, \
+            mock.patch.object(price_trigger, '_clear_event') as mock_clear_event:
+        price_trigger.update(
+            trigger_price=newest_price,
+            min_trigger_time=min_trigger_time,
+            update_event=False
+        )
+
+        assert price_trigger.trigger_price == newest_price
+        mock_clear_event.assert_not_called()
+        mock_create_event.assert_not_called()
+
+    # Test update with same price (should not trigger event updates)
+    with mock.patch.object(price_trigger, '_create_event') as mock_create_event, \
+            mock.patch.object(price_trigger, '_clear_event') as mock_clear_event:
+        price_trigger.update(
+            trigger_price=newest_price,
+            min_trigger_time=min_trigger_time,
+            update_event=True
+        )
+
+        assert price_trigger.trigger_price == newest_price
+        mock_clear_event.assert_not_called()
+        mock_create_event.assert_not_called()
+
+
+def test_create_event(price_trigger):
+    # Setup
+    callback = mock.Mock()
+    # Mock exchange manager and its components
+    exchange_manager = mock.Mock()
+    symbol_data = mock.Mock()
+    price_events_manager = mock.Mock()
+
+    exchange_manager.exchange_symbols_data.get_exchange_symbol_data.return_value = symbol_data
+    symbol_data.price_events_manager = price_events_manager
+
+    # Test event creation
+    min_trigger_time = 1234.56
+    price_trigger._exchange_manager = exchange_manager
+    price_trigger._symbol = "BTC/USD"
+
+    price_trigger._create_event(min_trigger_time)
+
+    # Verify the event was created with correct parameters
+    price_events_manager.new_event.assert_called_once_with(
+        price_trigger.trigger_price,
+        min_trigger_time,
+        price_trigger.trigger_above,
+        False
+    )
+
+    # Verify the event was stored
+    assert price_trigger._trigger_event == price_events_manager.new_event.return_value
+
 
 def test_str_representation(price_trigger):
     expected = (f"PriceTrigger({price_trigger.on_trigger_callback.__name__}): "

tests/personal_data/orders/types/limit/test_sell_limit_order.py

@@ -20,6 +20,7 @@
 from octobot_commons.asyncio_tools import wait_asyncio_next_cycle
 from octobot_trading.enums import TraderOrderType
 import octobot_trading.constants as trading_constants
+import octobot_trading.personal_data as personal_data
 
 from tests import event_loop
 from tests.exchanges import simulated_trader, simulated_exchange_manager
@@ -65,11 +66,14 @@ async def test_sell_limit_order_trigger(sell_limit_order):
 
 async def test_sell_limit_order_on_origin_price_change(sell_limit_order):
     order_price = decimal.Decimal(100)
+    group = personal_data.OneCancelsTheOtherOrderGroup("name", sell_limit_order.exchange_manager.exchange_personal_data.orders_manager)
     sell_limit_order.update(
         price=order_price,
         quantity=decimal_random_quantity(max_value=DEFAULT_SYMBOL_QUANTITY),
         symbol=DEFAULT_ORDER_SYMBOL,
         order_type=TraderOrderType.SELL_LIMIT,
+        group=group,
+        active_trigger=personal_data.create_order_price_trigger(sell_limit_order, order_price, True)
     )
     sell_limit_order.exchange_manager.is_backtesting = True  # force update_order_status
     await sell_limit_order.initialize()
@@ -83,13 +87,15 @@ async def test_sell_limit_order_on_origin_price_change(sell_limit_order):
                                      timestamp=sell_limit_order.timestamp)])
     await wait_asyncio_next_cycle()
     assert not sell_limit_order.is_filled()
+    assert sell_limit_order.active_trigger.trigger_price == decimal.Decimal(100)
 
     # do not update order price
     order_price = decimal.Decimal(10)
     sell_limit_order.update(
         symbol=sell_limit_order.symbol,
         quantity=decimal_random_quantity(max_value=DEFAULT_SYMBOL_QUANTITY)
     )
+    assert sell_limit_order.active_trigger.trigger_price == decimal.Decimal(100)    # did not change
     price_events_manager.handle_recent_trades(
         [decimal_random_recent_trade(price=decimal_random_price(max_value=order_price - trading_constants.ONE),
                                      timestamp=sell_limit_order.timestamp)])
@@ -103,6 +109,7 @@ async def test_sell_limit_order_on_origin_price_change(sell_limit_order):
         symbol=sell_limit_order.symbol,
         price=order_price
     )
+    assert sell_limit_order.active_trigger.trigger_price == decimal.Decimal(10)    # changed
     price_events_manager.handle_recent_trades([
         decimal_random_recent_trade(
             price=decimal.Decimal(20),