[TradingView] handle TRAILING_PROFILE for balanced order groups

Author: GuillaumeDSM

Trading/Mode/daily_trading_mode/daily_trading.py

@@ -14,6 +14,7 @@
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library.
 import asyncio
+import copy
 import decimal
 import math
 import dataclasses
@@ -28,13 +29,13 @@
 import octobot_evaluators.constants as evaluators_constants
 import octobot_evaluators.enums as evaluators_enums
 import octobot_evaluators.matrix as matrix
-import octobot_trading.personal_data as trading_personal_data
 import octobot_trading.constants as trading_constants
 import octobot_trading.errors as trading_errors
+import octobot_trading.api as trading_api
 import octobot_trading.modes as trading_modes
 import octobot_trading.modes.script_keywords as script_keywords
 import octobot_trading.enums as trading_enums
-import octobot_trading.api as trading_api
+import octobot_trading.personal_data as trading_personal_data
 
 
 @dataclasses.dataclass
@@ -194,6 +195,7 @@ class DailyTradingModeConsumer(trading_modes.AbstractTradingModeConsumer):
     TAKE_PROFIT_PRICE_KEY = "TAKE_PROFIT_PRICE"
     ADDITIONAL_TAKE_PROFIT_PRICES_KEY = "ADDITIONAL_TAKE_PROFIT_PRICES"
     STOP_ONLY = "STOP_ONLY"
+    TRAILING_PROFILE = "TRAILING_PROFILE"
     REDUCE_ONLY_KEY = "REDUCE_ONLY"
     TAG_KEY = "TAG"
     EXCHANGE_ORDER_IDS = "EXCHANGE_ORDER_IDS"
@@ -494,7 +496,8 @@ async def _create_order(
         self, current_order,
         use_take_profit_orders, take_profits_details: list[OrderDetails],
         use_stop_loss_orders, stop_loss_details: list[OrderDetails],
-        symbol_market, tag
+        symbol_market, tag,
+        trailing_profile_type: typing.Optional[trading_personal_data.TrailingProfileTypes]
     ):
         params = {}
         chained_orders = []
@@ -548,10 +551,20 @@ async def _create_order(
                 params.update(param_update)
                 chained_orders.append(chained_order)
         if len(chained_orders) > 1:
-            stop_count = len([o for o in chained_orders if trading_personal_data.is_stop_order(o.order_type)])
-            tp_count = len(chained_orders) - stop_count
-            group_type = trading_personal_data.OneCancelsTheOtherOrderGroup if stop_count == tp_count \
-                else trading_personal_data.BalancedTakeProfitAndStopOrderGroup
+            stop_orders = [o for o in chained_orders if trading_personal_data.is_stop_order(o.order_type)]
+            tp_orders = [o for o in chained_orders if not trading_personal_data.is_stop_order(o.order_type)]
+            if len(stop_orders) == len(tp_orders):
+                group_type = trading_personal_data.OneCancelsTheOtherOrderGroup
+            elif trailing_profile_type == trading_personal_data.TrailingProfileTypes.FILLED_TAKE_PROFIT:
+                group_type = trading_personal_data.TrailingOnFilledTPBalancedOrderGroup
+                entry_price = current_order.origin_price
+                for stop_order in stop_orders:
+                    # register trailing profile in stop orders
+                    stop_order.trailing_profile = trading_personal_data.create_filled_take_profit_trailing_profile(
+                        entry_price, tp_orders
+                    )
+            else:
+                group_type = trading_personal_data.BalancedTakeProfitAndStopOrderGroup
             oco_group = self.exchange_manager.exchange_personal_data.orders_manager.create_group(group_type)
             for order in chained_orders:
                 order.add_to_order_group(oco_group)
@@ -627,6 +640,9 @@ async def create_new_orders(self, symbol, final_note, state, **kwargs):
             if create_stop_only and (not user_stop_price or user_stop_price.is_nan()):
                 self.logger.error("Stop price is required to create a stop order")
                 return []
+            trailing_profile_type = trading_personal_data.TrailingProfileTypes(
+                data[self.TRAILING_PROFILE]
+            ) if data.get(self.TRAILING_PROFILE) else None
             is_reducing_position = not increasing_position
             if self.USE_TARGET_PROFIT_MODE:
                 if is_reducing_position:
@@ -697,7 +713,8 @@ async def create_new_orders(self, symbol, final_note, state, **kwargs):
                         current_order,
                         use_chained_take_profit_orders, take_profit_order_details,
                         use_chained_stop_loss_orders, stop_loss_order_details,
-                        symbol_market, tag
+                        symbol_market, tag,
+                        trailing_profile_type
                     ):
                         created_orders.append(current_order)
 
@@ -733,7 +750,8 @@ async def create_new_orders(self, symbol, final_note, state, **kwargs):
                         current_order,
                         use_chained_take_profit_orders, take_profit_order_details,
                         use_chained_stop_loss_orders, stop_loss_order_details,
-                        symbol_market, tag
+                        symbol_market, tag,
+                        trailing_profile_type
                     )):
                         if updated_limit:
                             created_orders.append(updated_limit)
@@ -801,7 +819,8 @@ async def create_new_orders(self, symbol, final_note, state, **kwargs):
                         current_order,
                         use_chained_take_profit_orders, take_profit_order_details,
                         use_chained_stop_loss_orders, stop_loss_order_details,
-                        symbol_market, tag
+                        symbol_market, tag,
+                        trailing_profile_type
                     )):
                         if updated_limit:
                             created_orders.append(updated_limit)
@@ -863,7 +882,8 @@ async def create_new_orders(self, symbol, final_note, state, **kwargs):
                         current_order,
                         use_chained_take_profit_orders, take_profit_order_details,
                         use_chained_stop_loss_orders, stop_loss_order_details,
-                        symbol_market, tag
+                        symbol_market, tag,
+                        trailing_profile_type
                     ):
                         created_orders.append(current_order)
             if created_orders:

Trading/Mode/daily_trading_mode/tests/test_daily_trading_mode_consumer.py

@@ -958,6 +958,7 @@ async def test_chained_stop_loss_and_take_profit_orders(tools):
     assert stop_order.associated_entry_ids == [buy_order.order_id]
     assert stop_order.tag == "super"
     assert stop_order.reduce_only is False
+    assert stop_order.trailing_profile is None
     assert stop_order.is_open()
 
     state = trading_enums.EvaluatorStates.LONG.value
@@ -977,6 +978,7 @@ async def test_chained_stop_loss_and_take_profit_orders(tools):
     assert take_profit_order.origin_price == decimal.Decimal("100000")
     assert take_profit_order.is_waiting_for_chained_trigger
     assert take_profit_order.associated_entry_ids == [buy_order.order_id]
+    assert take_profit_order.trailing_profile is None
     assert not take_profit_order.is_open()
     assert not take_profit_order.is_created()
     assert take_profit_order.reduce_only is False
@@ -998,6 +1000,7 @@ async def test_chained_stop_loss_and_take_profit_orders(tools):
     assert not take_profit_order.is_open()
     assert not take_profit_order.is_created()
     assert take_profit_order.reduce_only is False
+    assert take_profit_order.trailing_profile is None
 
     # stop loss and take profit
     data = {
@@ -1015,6 +1018,7 @@ async def test_chained_stop_loss_and_take_profit_orders(tools):
     assert stop_order.origin_price == decimal.Decimal("123")
     assert stop_order.is_waiting_for_chained_trigger
     assert stop_order.associated_entry_ids == [buy_order.order_id]
+    assert stop_order.trailing_profile is None
     assert not take_profit_order.is_open()
     assert not take_profit_order.is_created()
     take_profit_order = buy_order.chained_orders[1]
@@ -1029,6 +1033,7 @@ async def test_chained_stop_loss_and_take_profit_orders(tools):
     assert take_profit_order.reduce_only is False
     assert isinstance(stop_order.order_group, trading_personal_data.OneCancelsTheOtherOrderGroup)
     assert take_profit_order.order_group is stop_order.order_group
+    assert take_profit_order.trailing_profile is None
 
     # stop loss and take profit but decreasing position size: create stop loss and no take profit
     # (this initial order is a take profit already)
@@ -1050,6 +1055,7 @@ async def test_chained_stop_loss_and_take_profit_orders(tools):
     assert stop_loss.chained_orders == []
     assert stop_loss.reduce_only is True    # True as force stop loss
     assert stop_loss.origin_price == decimal.Decimal("123")
+    assert stop_loss.trailing_profile is None
     assert stop_loss.origin_quantity == decimal.Decimal("0.01") \
            - trading_personal_data.get_fees_for_currency(sell_limit.fee, stop_loss.quantity_currency)
 
@@ -1087,11 +1093,12 @@ async def test_chained_multiple_take_profit_orders(tools):
         assert not take_profit_order.is_open()
         assert not take_profit_order.is_created()
         assert take_profit_order.update_with_triggering_order_fees == is_last
+        assert take_profit_order.trailing_profile is None
 
     # only 2 additional (2 in total)
     data = {
         consumer.ADDITIONAL_TAKE_PROFIT_PRICES_KEY: [decimal.Decimal("110000"), decimal.Decimal("120000")],
-        consumer.VOLUME_KEY: decimal.Decimal("0.01"),
+        consumer.VOLUME_KEY: decimal.Decimal("0.01"), consumer.TRAILING_PROFILE: None
     }
     orders_with_tps = await consumer.create_new_orders(symbol, decimal.Decimal(str(-1)), state, data=data)
     buy_order = orders_with_tps[0]
@@ -1110,6 +1117,7 @@ async def test_chained_multiple_take_profit_orders(tools):
         assert not take_profit_order.is_open()
         assert not take_profit_order.is_created()
         assert take_profit_order.update_with_triggering_order_fees == is_last
+        assert take_profit_order.trailing_profile is None
 
     # stop loss and 1 take profit and 5 additional (6 TP in total)
     tp_prices = [
@@ -1134,6 +1142,7 @@ async def test_chained_multiple_take_profit_orders(tools):
     assert stop_order.is_waiting_for_chained_trigger
     assert stop_order.associated_entry_ids == [buy_order.order_id]
     assert stop_order.update_with_triggering_order_fees is True
+    assert stop_order.trailing_profile is None
     assert len(buy_order.chained_orders[1:]) == len(tp_prices)
     for i, take_profit_order in enumerate(buy_order.chained_orders[1:]):
         is_last = i == len(buy_order.chained_orders[1:]) - 1
@@ -1150,6 +1159,64 @@ async def test_chained_multiple_take_profit_orders(tools):
         assert isinstance(stop_order.order_group, trading_personal_data.BalancedTakeProfitAndStopOrderGroup)
         assert take_profit_order.order_group is stop_order.order_group
         assert take_profit_order.update_with_triggering_order_fees == is_last
+        assert take_profit_order.trailing_profile is None
+
+
+async def test_chained_multiple_take_profit_with_filled_tp_trailing_stop_orders(tools):
+    exchange_manager, trader, symbol, consumer, last_btc_price = tools
+
+    # with BTC/USDT
+    exchange_manager.exchange_personal_data.portfolio_manager.portfolio_value_holder.value_converter.last_prices_by_trading_pair[symbol] = \
+        last_btc_price
+    exchange_manager.exchange_personal_data.portfolio_manager.portfolio_value_holder.portfolio_current_value = \
+        decimal.Decimal(str(10 + 1000 / last_btc_price))
+
+    state = trading_enums.EvaluatorStates.LONG.value
+    # stop loss and 1 take profit and 5 additional (6 TP in total)
+    tp_prices = [
+        decimal.Decimal("100012"),
+        decimal.Decimal("110000"), decimal.Decimal("120000"), decimal.Decimal("130000"),
+        decimal.Decimal("140000"), decimal.Decimal("150000")
+    ]
+    data = {
+        consumer.STOP_PRICE_KEY: decimal.Decimal("123"),
+        consumer.TAKE_PROFIT_PRICE_KEY: tp_prices[0],
+        consumer.ADDITIONAL_TAKE_PROFIT_PRICES_KEY: tp_prices[1:],
+        consumer.VOLUME_KEY: decimal.Decimal("0.01"),
+        consumer.TRAILING_PROFILE: trading_personal_data.TrailingProfileTypes.FILLED_TAKE_PROFIT.value,
+    }
+    orders_with_tp = await consumer.create_new_orders(symbol, decimal.Decimal(str(0.4)), state, data=data)
+    buy_order = orders_with_tp[0]
+    assert len(buy_order.chained_orders) == 1 + len(tp_prices)
+    stop_order = buy_order.chained_orders[0]
+    assert isinstance(stop_order, trading_personal_data.StopLossOrder)
+    assert stop_order.origin_quantity == decimal.Decimal("0.01") \
+           - trading_personal_data.get_fees_for_currency(buy_order.fee, stop_order.quantity_currency)
+    assert stop_order.origin_price == decimal.Decimal("123")
+    assert stop_order.is_waiting_for_chained_trigger
+    assert stop_order.associated_entry_ids == [buy_order.order_id]
+    assert stop_order.update_with_triggering_order_fees is True
+    assert stop_order.trailing_profile == trading_personal_data.FilledTakeProfitTrailingProfile([
+        trading_personal_data.TrailingPriceStep(float(trailing_price), float(trigger_price), True)
+        for trailing_price, trigger_price in zip([buy_order.origin_price] + tp_prices[:-1], tp_prices)
+    ])
+    assert len(buy_order.chained_orders[1:]) == len(tp_prices)
+    for i, take_profit_order in enumerate(buy_order.chained_orders[1:]):
+        is_last = i == len(buy_order.chained_orders[1:]) - 1
+        assert isinstance(take_profit_order, trading_personal_data.SellLimitOrder)
+        assert take_profit_order.origin_quantity == (
+            decimal.Decimal("0.01")
+           - trading_personal_data.get_fees_for_currency(buy_order.fee, take_profit_order.quantity_currency)
+        ) / decimal.Decimal(str(len(tp_prices)))
+        assert take_profit_order.origin_price == tp_prices[i]
+        assert take_profit_order.is_waiting_for_chained_trigger
+        assert take_profit_order.associated_entry_ids == [buy_order.order_id]
+        assert not take_profit_order.is_open()
+        assert not take_profit_order.is_created()
+        assert isinstance(stop_order.order_group, trading_personal_data.TrailingOnFilledTPBalancedOrderGroup)
+        assert take_profit_order.order_group is stop_order.order_group
+        assert take_profit_order.update_with_triggering_order_fees == is_last
+        assert take_profit_order.trailing_profile is None
 
 
 async def test_create_stop_loss_orders(tools):

Trading/Mode/remote_trading_signals_trading_mode/remote_trading_signals_trading.py

@@ -383,6 +383,16 @@ async def _create_order(self, order_description, symbol, created_groups, fees_cu
             trading_enums.TradingSignalOrdersAttrs.ASSOCIATED_ORDER_IDS.value, None
         )
         trigger_above = order_description.get(trading_enums.TradingSignalOrdersAttrs.TRIGGER_ABOVE.value, None)
+        trailing_profile = None
+        if trailing_profile_details := order_description.get(
+            trading_enums.TradingSignalOrdersAttrs.TRAILING_PROFILE.value
+        ):
+            trailing_profile = personal_data.create_trailing_profile(
+                personal_data.TrailingProfileTypes(
+                    order_description[trading_enums.TradingSignalOrdersAttrs.TRAILING_PROFILE_TYPE.value],
+                ),
+                trailing_profile_details
+            )
         order = personal_data.create_order_instance(
             trader=self.exchange_manager.trader,
             order_type=order_type,
@@ -397,7 +407,8 @@ async def _create_order(self, order_description, symbol, created_groups, fees_cu
             group=group,
             fees_currency_side=fees_currency_side,
             reduce_only=reduce_only,
-            associated_entry_id=associated_entries[0] if associated_entries else None
+            associated_entry_id=associated_entries[0] if associated_entries else None,
+            trailing_profile=trailing_profile,
         )
         if associated_entries and len(associated_entries) > 1:
             for associated_entry in associated_entries[1:]:
@@ -409,7 +420,7 @@ async def _create_order(self, order_description, symbol, created_groups, fees_cu
 
     def _get_or_create_order_group(self, order_description, group_id):
         group_type = order_description[trading_enums.TradingSignalOrdersAttrs.GROUP_TYPE.value]
-        group_class = tentacles_management.get_class_from_parent_subclasses(group_type, personal_data.OrderGroup)
+        group_class = tentacles_management.get_deep_class_from_parent_subclasses(group_type, personal_data.OrderGroup)
         return self.exchange_manager.exchange_personal_data.orders_manager.get_or_create_group(group_class, group_id)
 
     async def _create_orders(self, orders_descriptions, symbol):