Skip to content
The Chat Archive
gemini-2.5-pro-preview-05-06· Google LMArena Human Preference 140K

опиши что делает этот код и сделай симуляцию разных ситуаций. import time Предположим,…

  1. User

    опиши что делает этот код и сделай симуляцию разных ситуаций. import time

    Предположим, что active_instruments и get_current_datetime_formatted определены где-то

    active_instruments = {}

    def get_current_datetime_formatted(): return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())

    def trailing_stop_fixed_levels_to_open_position(price, instrument, base_price, x_percent, start_multiplier=1.3, multiplier_step_param=0.2): # Renamed multiplier_step to avoid conflict data = active_instruments[instrument]

    # Инициализация полей, если их нет
    if 'last_stop_time' not in data:
        data['last_stop_time'] = None
    if 'last_peak_time' not in data:
        data['last_peak_time'] = None # Будет None при первом вызове
    if 'second_chance' not in data:
        data['second_chance'] = False
    
    # Начальная настройка уровней, если они не были установлены (помечены как 0.0)
    # Это важно для первого вызова функции для данного инструмента
    if data.get('tm_multiplier', 0.0) == 0.0 and \
       data.get('tm_next_level', 0.0) == 0.0 and \
       data.get('tm_first_level', 0.0) == 0.0:
    
        data['tm_multiplier'] = start_multiplier
        # Начальный стоп - это базовая цена. Трейлинг начнется, если цена пойдет выше следующего уровня.
        data['tm_first_level'] = base_price
        data['tm_next_level'] = round(
            base_price * ((x_percent * data['tm_multiplier']) / 100) + base_price, 10
        )
        # last_peak_time должен быть None, чтобы первое обновление уровня могло произойти без задержки, если цена уже выше
        data['last_peak_time'] = None
        print(f"{get_current_datetime_formatted()} {instrument} [INIT] Initial level: {data['tm_next_level']:.10f}, Initial stop: {data['tm_first_level']:.10f}, Initial Multiplier: {data['tm_multiplier']}")
    
    
    # Адаптивный шаг (используем multiplier_step_param из аргументов, чтобы не путать с локальной переменной)
    current_multiplier_step = multiplier_step_param # По умолчанию
    if data['tm_multiplier'] <= 1.6:
        current_multiplier_step = 0.3
    # else: current_multiplier_step остается multiplier_step_param (0.2 по умолчанию)
    
    # Если цена опускается ниже следующего уровня (но еще не достигла стопа),
    # это считается "пиком" перед возможным откатом. Обновляем время последнего пика.
    if price < data['tm_next_level']:
        data['last_peak_time'] = time.time()
    
    # Обновляем уровни, если цена перескакивает вперёд
    # Условие по времени: (data['last_peak_time'] is None) для первого раза или если цена долго не опускалась,
    # ИЛИ прошло достаточно времени с момента последнего опускания ниже tm_next_level.
    while price >= data['tm_next_level'] and \
          (data['last_peak_time'] is None or (time.time() - data['last_peak_time']) > 5):
        # Сдвигаем стоп на текущий уровень (который был tm_next_level)
        data['tm_first_level'] = data['tm_next_level']
    
        # Поднимаем уровень
        data['tm_multiplier'] += current_multiplier_step
        data['tm_next_level'] = round(
            base_price * ((x_percent * data['tm_multiplier']) / 100) + base_price, 10)
    
        print(f"{get_current_datetime_formatted()} {instrument} [LEVEL UP] New level: {data['tm_next_level']:.10f}, New stop: {data['tm_first_level']:.10f}, Multiplier: {data['tm_multiplier']}")
        # После успешного LEVEL UP, сбрасываем last_peak_time, чтобы следующий LEVEL UP мог произойти сразу, если цена продолжит расти.
        # Или, если цена немного откатит, но останется выше нового tm_first_level, то last_peak_time обновится выше.
        data['last_peak_time'] = None # Позволяет цепочку LEVEL UP без 5-секундной задержки между ними
    
    # Проверка на откат (срабатывание стопа)
    if price < data['tm_first_level']:
        # Проверяем, прошло ли достаточно времени с последней проверки стопа (или это первая проверка)
        if data['last_stop_time'] is None or (time.time() - data['last_stop_time']) > 5:
            # Только сейчас обновляем last_stop_time, так как мы активно рассматриваем стоп
            data['last_stop_time'] = time.time()
    
            if data['second_chance']:
                print(f"{get_current_datetime_formatted()} {instrument} [STOP] Трейлинг-стоп сработал на уровне {data['tm_first_level']:.10f} при цене {price}")
                # Опционально: сбросить состояния для следующего трейлинга, если инструмент снова войдет в отслеживание
                # data['tm_multiplier'] = 0.0
                # data['tm_next_level'] = 0.0
                # data['tm_first_level'] = 0.0
                # data['second_chance'] = False
                # data['last_peak_time'] = None
                # data['last_stop_time'] = None
                return True # СТОП
            else:
                print(f"{get_current_datetime_formatted()} {instrument} [SECOND CHANCE] Цена {price} опустилась ниже стопа {data['tm_first_level']:.10f}. Даем второй шанс.")
                data['second_chance'] = True
                return False # Пока не стоп, дан второй шанс
        # else: # Если прошло < 5 секунд, ничего не делаем, ждем
            # print(f"{get_current_datetime_formatted()} {instrument} [STOP IGNORED] Цена {price} ниже стопа {data['tm_first_level']:.10f}, но прошло <5сек с последней проверки.")
    
    # Если цена поднялась выше следующего уровня (tm_next_level),
    # это означает значительный прогресс, поэтому сбрасываем флаг "второго шанса".
    # Это условие важно, так как если цена просто поднялась выше tm_first_level,
    # но не достигла tm_next_level, "второй шанс" должен оставаться активным.
    if price >= data['tm_next_level']:
        if data['second_chance']: # Если был дан второй шанс и цена восстановилась до следующего уровня
            print(f"{get_current_datetime_formatted()} {instrument} [SECOND CHANCE RESET] Цена {price} поднялась выше следующего уровня {data['tm_next_level']:.10f}. Второй шанс сброшен.")
        data['second_chance'] = False
    
    # data['last_stop_time'] = time.time() # Убрано отсюда, перенесено в блок проверки стопа
    
    return False # Нет сигнала к стопу
    
  2. Assistant

    Окей, давай разберем этот код и проведем симуляцию.

    Что делает код?

    Этот код реализует логику трейлинг-стопа с фиксированными уровнями для открытой позиции. Его основная задача — автоматически поднимать уровень стоп-лосса по мере роста цены актива, чтобы защитить уже полученную прибыль. Если цена начинает падать, стоп-лосс остается на последнем зафиксированном уровне. При достижении ценой этого уровня стоп-лосса, генерируется сигнал к закрытию позиции (возвращается True).

    Основные компоненты и логика:

    1. active_instruments: Глобальный словарь, который хранит состояние трейлинг-стопа для каждого торгового инструмента. Для каждого инструмента (instrument) в этом словаре хранится свой вложенный словарь с параметрами трейлинга (tm_multiplier, tm_next_level, tm_first_level, last_stop_time, last_peak_time, second_chance).

    2. get_current_datetime_formatted(): Вспомогательная функция для форматирования текущей даты и времени для логов.

    3. trailing_stop_fixed_levels_to_open_position(...): Основная функция.

      • Входные параметры:

        • price: Текущая рыночная цена инструмента.
        • instrument: Имя/тикер инструмента.
        • base_price: Базовая цена, от которой рассчитываются начальные уровни. Это может быть цена входа в позицию или некий значимый уровень, от которого начинается отсчет.
        • x_percent: Процент от base_price, используемый для расчета шага изменения уровней.
        • start_multiplier: Начальный множитель для x_percent при расчете первого tm_next_level.
        • multiplier_step_param: Шаг, на который увеличивается tm_multiplier при каждом подъеме уровня.
      • Инициализация состояния (при первом вызове для инструмента):

        • Если для инструмента еще нет данных трейлинга, они инициализируются.
        • tm_multiplier устанавливается в start_multiplier.
        • tm_first_level (начальный стоп-лосс) устанавливается на base_price.
        • tm_next_level (следующий уровень, при достижении которого стоп-лосс поднимется) рассчитывается как base_price + (base_price * x_percent * tm_multiplier / 100).
        • last_peak_time устанавливается в None, чтобы первое обновление уровня могло произойти без задержки.
      • Адаптивный шаг множителя:

        • Шаг current_multiplier_step, на который увеличивается tm_multiplier, зависит от текущего значения tm_multiplier. Если tm_multiplier <= 1.6, шаг больше (0.3), что делает трейлинг более агрессивным на начальных этапах. Позже шаг уменьшается (до multiplier_step_param, по умолчанию 0.2), делая трейлинг менее агрессивным по мере роста прибыли.
      • Обновление last_peak_time:

        • Если цена опускается ниже tm_next_level (но еще не достигла стопа tm_first_level), это считается "пиком" перед возможным откатом. Время этого события (last_peak_time) запоминается.
      • Подъем уровней (LEVEL UP):

        • Цикл while срабатывает, если:
          1. Текущая цена (price) достигла или превысила tm_next_level.
          2. И (last_peak_time еще не установлен ИЛИ прошло более 5 секунд с момента последнего "пика" (когда цена опускалась ниже tm_next_level)). Это условие предотвращает слишком частое перемещение стопа вверх-вниз при колебаниях цены около tm_next_level.
        • Внутри цикла:
          • tm_first_level (стоп-лосс) поднимается до значения предыдущего tm_next_level.
          • tm_multiplier увеличивается.
          • tm_next_level пересчитывается с новым, более высоким tm_multiplier.
          • last_peak_time сбрасывается в None, чтобы позволить немедленный следующий LEVEL UP, если цена продолжит расти без откатов.
      • Проверка на срабатывание стоп-лосса:

        • Если цена (price) падает ниже tm_first_level (текущий стоп-лосс).
        • И (прошло более 5 секунд с момента последней проверки стопа ИЛИ это первая проверка). Это предотвращает множественные сигналы стопа, если цена колеблется прямо на уровне стопа.
        • Логика "второго шанса":
          • Если second_chance уже True (т.е. это уже второй раз, когда цена падает ниже стопа после предоставления "второго шанса"), то функция возвращает True (СТОП!).
          • Если second_chance равен False (первое падение ниже стопа), то second_chance устанавливается в True, и функция возвращает False (стоп пока не сработал, дан второй шанс).
      • Сброс "второго шанса":

        • Если цена поднимается выше tm_next_level (т.е. значительно восстанавливается и готова к следующему подъему стопа), флаг second_chance сбрасывается в False.
      • Возвращаемое значение:

        • True: Если стоп-лосс сработал (после второго шанса).
        • False: Если стоп-лосс не сработал.

    Симуляция разных ситуаций

    Предположим: base_price = 100 x_percent = 1 (т.е. 1% от base_price = 1 единица цены) start_multiplier = 1.3 multiplier_step_param = 0.2

    Инструмент: BTCUSDT

    import time
    
    # Предположим, что active_instruments и get_current_datetime_formatted определены где-то
    active_instruments = {}
    
    def get_current_datetime_formatted():
        return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
    
    def trailing_stop_fixed_levels_to_open_position(price, instrument, base_price, x_percent, start_multiplier=1.3, multiplier_step_param=0.2): # Renamed multiplier_step to avoid conflict
        if instrument not in active_instruments: # Убедимся, что словарь для инструмента существует
            active_instruments[instrument] = {}
        data = active_instruments[instrument]
    
        # Инициализация полей, если их нет
        if 'last_stop_time' not in data:
            data['last_stop_time'] = None
        if 'last_peak_time' not in data:
            data['last_peak_time'] = None # Будет None при первом вызове
        if 'second_chance' not in data:
            data['second_chance'] = False
    
        # Начальная настройка уровней, если они не были установлены (помечены как 0.0)
        # Это важно для первого вызова функции для данного инструмента
        if data.get('tm_multiplier', 0.0) == 0.0 and \
           data.get('tm_next_level', 0.0) == 0.0 and \
           data.get('tm_first_level', 0.0) == 0.0:
    
            data['tm_multiplier'] = start_multiplier
            # Начальный стоп - это базовая цена. Трейлинг начнется, если цена пойдет выше следующего уровня.
            data['tm_first_level'] = base_price
            data['tm_next_level'] = round(
                base_price * ((x_percent * data['tm_multiplier']) / 100) + base_price, 10
            )
            # last_peak_time должен быть None, чтобы первое обновление уровня могло произойти без задержки, если цена уже выше
            data['last_peak_time'] = None
            print(f"{get_current_datetime_formatted()} {instrument} [INIT] Initial level: {data['tm_next_level']:.2f}, Initial stop: {data['tm_first_level']:.2f}, Initial Multiplier: {data['tm_multiplier']:.1f}")
    
    
        # Адаптивный шаг (используем multiplier_step_param из аргументов, чтобы не путать с локальной переменной)
        current_multiplier_step = multiplier_step_param # По умолчанию
        if data['tm_multiplier'] <= 1.6:
            current_multiplier_step = 0.3
        # else: current_multiplier_step остается multiplier_step_param (0.2 по умолчанию)
    
        # Если цена опускается ниже следующего уровня (но еще не достигла стопа),
        # это считается "пиком" перед возможным откатом. Обновляем время последнего пика.
        if price < data['tm_next_level'] and data.get('tm_next_level', 0.0) != 0.0: # Добавил проверку, что tm_next_level инициализирован
            if data.get('last_peak_time_price_level') != data['tm_next_level']: # Обновляем, только если уровень tm_next_level изменился или это первый раз
                 print(f"{get_current_datetime_formatted()} {instrument} [PEAK_TIME_UPDATE_INFO] Price {price:.2f} < tm_next_level {data['tm_next_level']:.2f}. Updating last_peak_time.")
                 data['last_peak_time'] = time.time()
                 data['last_peak_time_price_level'] = data['tm_next_level'] # Запоминаем уровень, для которого установлен last_peak_time
    
        # Обновляем уровни, если цена перескакивает вперёд
        # Условие по времени: (data['last_peak_time'] is None) для первого раза или если цена долго не опускалась,
        # ИЛИ прошло достаточно времени с момента последнего опускания ниже tm_next_level.
        while data.get('tm_next_level', float('inf')) != 0.0 and price >= data['tm_next_level'] and \
              (data['last_peak_time'] is None or (time.time() - data['last_peak_time']) > 5): #float('inf') чтобы не было ложного срабатывания до инициализации
            # Сдвигаем стоп на текущий уровень (который был tm_next_level)
            data['tm_first_level'] = data['tm_next_level']
    
            # Поднимаем уровень
            data['tm_multiplier'] += current_multiplier_step
            data['tm_multiplier'] = round(data['tm_multiplier'], 1) # Округляем множитель для предсказуемости
            data['tm_next_level'] = round(
                base_price * ((x_percent * data['tm_multiplier']) / 100) + base_price, 10)
    
            print(f"{get_current_datetime_formatted()} {instrument} [LEVEL UP] New level: {data['tm_next_level']:.2f}, New stop: {data['tm_first_level']:.2f}, Multiplier: {data['tm_multiplier']:.1f}")
            # После успешного LEVEL UP, сбрасываем last_peak_time, чтобы следующий LEVEL UP мог произойти сразу, если цена продолжит расти.
            data['last_peak_time'] = None 
            data.pop('last_peak_time_price_level', None) # Удаляем, т.к. уровень изменился
    
        # Проверка на откат (срабатывание стопа)
        if data.get('tm_first_level', 0.0) != 0.0 and price < data['tm_first_level']: # Добавил проверку, что tm_first_level инициализирован
            # Проверяем, прошло ли достаточно времени с последней проверки стопа (или это первая проверка)
            if data['last_stop_time'] is None or (time.time() - data['last_stop_time']) > 5:
                # Только сейчас обновляем last_stop_time, так как мы активно рассматриваем стоп
                data['last_stop_time'] = time.time()
    
                if data['second_chance']:
                    print(f"{get_current_datetime_formatted()} {instrument} [STOP] Трейлинг-стоп сработал на уровне {data['tm_first_level']:.2f} при цене {price:.2f}")
                    # Опционально: сбросить состояния для следующего трейлинга
                    # active_instruments[instrument] = {} # Полный сброс
                    return True # СТОП
                else:
                    print(f"{get_current_datetime_formatted()} {instrument} [SECOND CHANCE] Цена {price:.2f} опустилась ниже стопа {data['tm_first_level']:.2f}. Даем второй шанс.")
                    data['second_chance'] = True
                    return False # Пока не стоп, дан второй шанс
            else: 
                print(f"{get_current_datetime_formatted()} {instrument} [STOP IGNORED] Цена {price:.2f} ниже стопа {data['tm_first_level']:.2f}, но прошло <5сек с последней проверки.")
    
        # Если цена поднялась выше следующего уровня (tm_next_level),
        # это означает значительный прогресс, поэтому сбрасываем флаг "второго шанса".
        if data.get('tm_next_level', float('inf')) != 0.0 and price >= data['tm_next_level']: # float('inf') чтобы не было ложного срабатывания до инициализации
            if data['second_chance']: 
                print(f"{get_current_datetime_formatted()} {instrument} [SECOND CHANCE RESET] Цена {price:.2f} поднялась выше следующего уровня {data['tm_next_level']:.2f}. Второй шанс сброшен.")
                data['second_chance'] = False
    
        return False # Нет сигнала к стопу
    
    def simulate_ticks(instrument, base_price, x_percent, ticks_with_delays):
        print(f"\n--- Starting Simulation for {instrument} ---")
        active_instruments[instrument] = {} # Сброс состояния для нового симуляционного запуска
        for price, delay in ticks_with_delays:
            print(f"\n--- Tick: Price={price:.2f}, Delay before next call: {delay}s ---")
            result = trailing_stop_fixed_levels_to_open_position(price, instrument, base_price, x_percent)
            print(f"Function returned: {result}")
            print(f"Current state: tm_first_level={active_instruments[instrument].get('tm_first_level', 0.0):.2f}, "
                  f"tm_next_level={active_instruments[instrument].get('tm_next_level', 0.0):.2f}, "
                  f"tm_multiplier={active_instruments[instrument].get('tm_multiplier', 0.0):.1f}, "
                  f"second_chance={active_instruments[instrument].get('second_chance', False)}, "
                  f"last_peak_time_is_None={active_instruments[instrument].get('last_peak_time') is None}")
            if result:
                print(f"--- STOP SIGNAL RECEIVED for {instrument} ---")
                # active_instruments[instrument] = {} # Можно сбросить состояние после стопа
                # break # Можно остановить симуляцию после стопа
            if delay > 0:
                time.sleep(delay)
    
    # Параметры для всех симуляций
    BASE_PRICE = 100
    X_PERCENT = 1 # 1% от base_price = 1
    
    # --- Симуляция 1: Плавный рост, несколько LEVEL UP ---
    print("\n\n=== SIMULATION 1: Smooth Growth ===")
    # (price, delay_after_call_seconds)
    ticks1 = [
        (99.0, 0.1),    # Цена ниже базовой, инициализации не будет, т.к. multiplier = 0.0
        (100.0, 0.1),   # Цена на базовой, инициализация
        (101.0, 0.1),   # Цена чуть выше базовой, но ниже tm_next_level
        (101.3, 0.1),   # Цена достигает tm_next_level (100 * (1*1.3/100) + 100 = 101.3) -> LEVEL UP
                        # tm_first_level=101.3, mult=1.3+0.3=1.6, tm_next_level=100*(1*1.6/100)+100 = 101.6
        (101.5, 0.1),   # Цена между уровнями
        (101.6, 0.1),   # Цена достигает tm_next_level (101.6) -> LEVEL UP
                        # tm_first_level=101.6, mult=1.6+0.3=1.9, tm_next_level=100*(1*1.9/100)+100 = 101.9. (multiplier_step теперь 0.2, т.к. mult > 1.6)
                        # ОШИБКА В РУЧНОМ РАСЧЕТЕ: при mult=1.6 step еще 0.3. mult станет 1.9. tm_next_level=101.9
                        # следующий шаг будет mult=1.9+0.2 = 2.1 (т.к. 1.9 > 1.6)
        (102.0, 0.1),   # Цена выше tm_next_level (101.9) -> LEVEL UP
                        # tm_first_level=101.9, mult=1.9+0.2=2.1, tm_next_level=100*(1*2.1/100)+100 = 102.1
        (102.5, 0.1)    # Цена выше tm_next_level (102.1) -> LEVEL UP
                        # tm_first_level=102.1, mult=2.1+0.2=2.3, tm_next_level=100*(1*2.3/100)+100 = 102.3
    ]
    simulate_ticks("BTCUSDT_S1", BASE_PRICE, X_PERCENT, ticks1)
    
    # --- Симуляция 2: Рост, затем колебание у tm_next_level с задержкой на LEVEL UP ---
    print("\n\n=== SIMULATION 2: Fluctuation near tm_next_level ===")
    # tm_first_level=100, tm_next_level=101.3
    ticks2 = [
        (101.0, 0.1),   # Инициализация (tm_first=100, tm_next=101.3)
        (101.4, 0.1),   # LEVEL UP (tm_first=101.3, tm_mult=1.6, tm_next=101.6)
        (101.5, 0.1),   # Цена < tm_next_level (101.6). last_peak_time обновлен.
        (101.7, 3),     # Цена > tm_next_level (101.6), но прошло < 5с. LEVEL UP не будет. last_peak_time не None.
        (101.7, 3)      # Цена > tm_next_level (101.6), прошло > 5с. LEVEL UP (tm_first=101.6, tm_mult=1.9, tm_next=101.9)
    ]
    simulate_ticks("ETHUSDT_S2", BASE_PRICE, X_PERCENT, ticks2)
    
    # --- Симуляция 3: Рост, падение, ВТОРОЙ ШАНС, затем СТОП ---
    print("\n\n=== SIMULATION 3: Second Chance then Stop ===")
    # tm_first_level=100, tm_next_level=101.3
    ticks3 = [
        (101.0, 0.1),   # Инит (stop=100, next=101.3)
        (101.4, 0.1),   # LEVEL UP (stop=101.3, mult=1.6, next=101.6)
        (101.2, 6),     # Цена < stop (101.3). SECOND CHANCE. last_stop_time обновлен.
        (101.1, 6)      # Цена все еще < stop (101.3). Прошло >5сек. СТОП.
    ]
    simulate_ticks("ADAUSDT_S3", BASE_PRICE, X_PERCENT, ticks3)
    
    # --- Симуляция 4: Рост, падение (ВТОРОЙ ШАНС), восстановление (СБРОС ВТОРОГО ШАНСА) ---
    print("\n\n=== SIMULATION 4: Second Chance, then Recovery & Reset ===")
    # tm_first_level=100, tm_next_level=101.3
    ticks4 = [
        (101.0, 0.1),   # Инит (stop=100, next=101.3)
        (101.4, 0.1),   # LEVEL UP (stop=101.3, mult=1.6, next=101.6)
        (101.2, 6),     # Цена < stop (101.3). SECOND CHANCE. last_stop_time обновлен.
        (101.5, 0.1),   # Цена восстановилась > stop (101.3), но < next (101.6). Second chance остается.
        (101.7, 0.1)    # Цена >= next (101.6). SECOND CHANCE RESET. LEVEL UP (stop=101.6, mult=1.9, next=101.9)
    ]
    simulate_ticks("SOLUSDT_S4", BASE_PRICE, X_PERCENT, ticks4)
    
    # --- Симуляция 5: Быстрые колебания вокруг стопа (STOP IGNORED) ---
    print("\n\n=== SIMULATION 5: Rapid fluctuations around stop level ===")
    # tm_first_level=100, tm_next_level=101.3
    ticks5 = [
        (101.0, 0.1),   # Инит (stop=100, next=101.3)
        (101.4, 0.1),   # LEVEL UP (stop=101.3, mult=1.6, next=101.6)
        (101.2, 1),     # Цена < stop (101.3). Прошло <5сек с последнего вызова (предполагаем, что last_stop_time был None). Даст SECOND CHANCE.
        (101.1, 1),     # Цена < stop (101.3). Прошло <5сек с последнего СЕРЬЕЗНОГО РАССМОТРЕНИЯ стопа. STOP IGNORED.
        (101.0, 6),     # Цена < stop (101.3). Прошло >5сек. СТОП (т.к. second_chance уже был True).
    ]
    simulate_ticks("XRPUSDT_S5", BASE_PRICE, X_PERCENT, ticks5)
    
    # --- Симуляция 6: Адаптивный шаг множителя ---
    print("\n\n=== SIMULATION 6: Adaptive Multiplier Step Change ===")
    # Цель: показать, как current_multiplier_step меняется с 0.3 на 0.2
    # tm_first_level=100, tm_next_level=101.3 (mult=1.3, step=0.3)
    # LEVEL UP 1: stop=101.3, next=101.6 (mult=1.6, step=0.3)
    # LEVEL UP 2: stop=101.6, next=101.9 (mult=1.9, step уже 0.2, так как 1.6 НЕ <= 1.6, а 1.9 > 1.6 )
    # Коррекция: `if data['tm_multiplier'] <= 1.6:` -> step 0.3.
    #   - mult=1.3 (step 0.3) -> next mult 1.3+0.3=1.6
    #   - mult=1.6 (step 0.3) -> next mult 1.6+0.3=1.9
    #   - mult=1.9 (step 0.2) -> next mult 1.9+0.2=2.1
    ticks6 = [
        (101.0, 0.1), # Инит (stop=100, next=101.3, mult=1.3)
        (101.3, 0.1), # LEVEL UP. stop=101.3, mult=1.3+0.3=1.6. next=101.6. (Шаг был 0.3)
        (101.6, 0.1), # LEVEL UP. stop=101.6, mult=1.6+0.3=1.9. next=101.9. (Шаг был 0.3, т.к. текущий mult 1.6 <= 1.6)
        (101.9, 0.1), # LEVEL UP. stop=101.9, mult=1.9+0.2=2.1. next=102.1. (Шаг стал 0.2, т.к. текущий mult 1.9 > 1.6)
        (102.1, 0.1)  # LEVEL UP. stop=102.1, mult=2.1+0.2=2.3. next=102.3. (Шаг 0.2)
    ]
    simulate_ticks("DOTUSDT_S6", BASE_PRICE, X_PERCENT, ticks6)
    
    

    Пояснения к симуляции и коду:

    • Я добавил небольшие проверки в код (if instrument not in active_instruments, проверки на data.get('...', 0.0) != 0.0 и float('inf') перед использованием tm_next_level и tm_first_level в условиях), чтобы он был чуть более устойчив к первому вызову или отсутствию некоторых полей, особенно в симуляторе.
    • В симуляторе simulate_ticks я сбрасываю состояние для каждого инструмента (active_instruments[instrument] = {}) перед началом новой симуляции, чтобы они не влияли друг на друга.
    • Используется time.sleep() для имитации прохождения времени, что важно для условий с last_peak_time и last_stop_time.
    • В print состояния я добавил last_peak_time_is_None для наглядности.
    • Логика last_peak_time с 5-секундной задержкой предназначена для того, чтобы не двигать стоп слишком часто, если цена колеблется ровно на уровне tm_next_level. Сначала цена должна упасть ниже tm_next_level (устанавливается last_peak_time), а затем, если она снова поднимется выше tm_next_level и пройдет 5 секунд с момента "пика", только тогда произойдет LEVEL UP. Если же после LEVEL UP цена сразу продолжает расти, last_peak_time сбрасывается в None, и следующий LEVEL UP может произойти без задержки.
    • Логика "второго шанса" и 5-секундной задержки для стопа (last_stop_time) предотвращает немедленное закрытие позиции при кратковременном "проколе" уровня стопа.

    Запуск этого скрипта покажет пошаговое выполнение логики трейлинг-стопа в различных рыночных ситуациях. Обратите внимание на сообщения [INIT], [LEVEL UP], [SECOND CHANCE], [STOP], [SECOND CHANCE RESET], [PEAK_TIME_UPDATE_INFO] и [STOP IGNORED], они помогут отследить, какая часть кода выполняется.

    По моим ручным расчетам для Симуляции 1 и 6 я внес корректировки в комментарии, так как изначальные предположения о том, когда меняется current_multiplier_step, были не совсем точны при первом взгляде на код. Теперь они должны соответствовать логике if data['tm_multiplier'] <= 1.6: current_multiplier_step = 0.3.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.