Update app.py

app.py

@@ -1,1175 +1 @@
-#!/usr/bin/env python3
-"""
-ICT Trading Bot - Версия 5.0 (ПОЛНАЯ)
-- Полные пояснения по ATR, FVG, волатильности
-- Логика London → NY (модели Нью-Йорка)
-- Фильтр мусорных сигналов (no trade day)
-- Нормальный вход по FVG
-- Нормальный RR (TP1/2/3)
-- Два сигнала: INFO + STRONG
-- Сопровождение сделки
-"""
-
-import os
-import sys
-import json
-import time
-import ccxt
-import pandas as pd
-import numpy as np
-import requests
-from datetime import datetime
-
-# =====================
-# 1. КОНФИГУРАЦИЯ
-# =====================
-TOKEN = "7715180236:AAH52V597ZRZ-BQl4RCZH3AiixDH0E6pSLw"
-CHAT_ID = "-1003125714543"
-
-if not TOKEN or not CHAT_ID:
-    print("❌ TELEGRAM_TOKEN или CHAT_ID не заданы!")
-    sys.exit(1)
-
-BASE_SYMBOL = "BTC/USDT"
-CONFIRM_SYMBOL = "ETH/USDT"
-STATE_FILE = "state.json"
-SIGNAL_FILE = "last_signal.json"
-
-# Настройки фильтров
-NO_TRADE_DAYS = [0, 6]  # 0 = понедельник, 6 = воскресенье (не торгуем)
-MIN_ATR_PERCENT = 0.5   # Минимальная волатильность 0.5%
-MIN_RATIO = 1.5         # Минимальное соотношение риск/прибыль
-
-# =====================
-# 2. РАБОТА С СОСТОЯНИЕМ
-# =====================
-def load_state():
-    try:
-        with open(STATE_FILE, "r") as f:
-            return json.load(f)
-    except:
-        return {
-            "active": False,
-            "direction": None,
-            "entry": None,
-            "sl": None,
-            "tp1": None,
-            "tp2": None,
-            "tp3": None,
-            "entered": False,
-            "tp1_hit": False,
-            "tp2_hit": False,
-            "tp3_hit": False,
-            "sl_hit": False,
-            "wins": 0,
-            "losses": 0
-        }
-
-def save_state(state):
-    with open(STATE_FILE, "w") as f:
-        json.dump(state, f, indent=4)
-
-def load_last_signal():
-    try:
-        with open(SIGNAL_FILE, "r") as f:
-            return json.load(f)
-    except:
-        return {
-            "timestamp": None,
-            "direction": None,
-            "h4_bias": None,
-            "h1_zone": None,
-            "candle_time": None
-        }
-
-def save_last_signal(signal):
-    with open(SIGNAL_FILE, "w") as f:
-        json.dump(signal, f, indent=4)
-
-def is_new_signal(current_signal, last_signal):
-    if last_signal["direction"] is None:
-        return True
-    if current_signal["direction"] != last_signal["direction"]:
-        return True
-    if current_signal["h4_bias"] != last_signal["h4_bias"]:
-        return True
-    if current_signal["h1_zone"] != last_signal["h1_zone"]:
-        return True
-    return False
-
-def stats_text(state):
-    total = state["wins"] + state["losses"]
-    if total == 0:
-        return "📊 Winrate: 0% (0/0)"
-    wr = state["wins"] / total * 100
-    return f"📊 Winrate: {wr:.1f}% ({state['wins']}/{total})"
-
-# =====================
-# 3. TELEGRAM
-# =====================
-def send_telegram(msg, retry=3):
-    for attempt in range(retry):
-        try:
-            r = requests.post(
-                f"https://api.telegram.org/bot{TOKEN}/sendMessage",
-                json={"chat_id": CHAT_ID, "text": msg, "parse_mode": "HTML"},
-                timeout=30
-            )
-            if r.status_code == 200:
-                print("✅ Отправлено")
-                return True
-            else:
-                print(f"❌ Ошибка: {r.text}")
-        except Exception as e:
-            print(f"❌ Попытка {attempt+1}/{retry} не удалась: {e}")
-            if attempt < retry - 1:
-                time.sleep(5)
-    return False
-
-# =====================
-# 4. ФИЛЬТРЫ И ЛОГИКА ДНЯ
-# =====================
-
-def get_day_name(weekday):
-    days = ["понедельник", "вторник", "среда", "четверг", "пятница", "суббота", "воскресенье"]
-    return days[weekday]
-
-def is_trade_day():
-    """Проверяем, можно ли сегодня торговать"""
-    today = datetime.utcnow().weekday()
-    if today in NO_TRADE_DAYS:
-        return False, f"📅 Сегодня {get_day_name(today)} - день без торгов (низкая ликвидность)"
-    return True, f"📅 Сегодня {get_day_name(today)} - торгуем"
-
-def get_london_direction(df_m5):
-    """
-    Определяем направление СЕГОДНЯШНЕЙ Лондонской сессии (06:00-12:00 UTC)
-    """
-    today = datetime.utcnow().date()
-    
-    # Ищем свечи только за сегодня с 06:00 до 12:00
-    london_bars = []
-    for i, ts in enumerate(df_m5['ts']):
-        if ts.date() == today and 6 <= ts.hour < 12:
-            london_bars.append(i)
-    
-    if len(london_bars) < 10:
-        return "range", "сег��дня Лондон ещё не начался или мало данных"
-    
-    first_idx = london_bars[0]
-    last_idx = london_bars[-1]
-    
-    london_open = df_m5['o'].iloc[first_idx]
-    london_close = df_m5['c'].iloc[last_idx]
-    change_percent = ((london_close - london_open) / london_open) * 100
-    
-    if london_close > london_open * 1.002:
-        return "bullish", f"📈 Лондон БЫЧИЙ (+{change_percent:.2f}%)"
-    elif london_close < london_open * 0.998:
-        return "bearish", f"📉 Лондон МЕДВЕЖИЙ ({change_percent:.2f}%)"
-    else:
-        return "range", f"📊 Лондон в РЕЙНДЖЕ ({change_percent:.2f}%)"
-
-def get_ny_model(london_direction, df_m5):
-    """
-    Модель Нью-Йорка на основе СЕГОДНЯШНЕГО направления Лондона
-    """
-    today = datetime.utcnow().date()
-    
-    # Находим свечу открытия Нью-Йорка (12:00 UTC) за сегодня
-    ny_open = None
-    ny_open_price = None
-    for i, ts in enumerate(df_m5['ts']):
-        if ts.date() == today and ts.hour == 12 and ts.minute == 0:
-            ny_open = i
-            ny_open_price = df_m5['o'].iloc[i]
-            break
-    
-    if ny_open is None:
-        return "нет данных (NY ещё не открылся)", "⚠️"
-    
-    current_price = df_m5['c'].iloc[-1]
-    price_change = (current_price - ny_open_price) / ny_open_price * 100
-    
-    if london_direction == "bullish":
-        if price_change > 0:
-            return "Модель 1: Лондон вверх → NY продолжает", "✅"
-        else:
-            return "Модель 2: Лондон вверх → NY разворачивается", "⚠️"
-    
-    elif london_direction == "bearish":
-        if price_change < 0:
-            return "Модель 1: Лондон вниз → NY продолжает", "✅"
-        else:
-            return "Модель 2: Лондон вниз → NY разворачивается", "⚠️"
-    
-    else:
-        return "Лондон в диапазоне → ждём импульса NY", "📊"
-
-def is_quality_signal(direction, atr, current_price, h4_bias, h1_zone, london_direction):
-    """
-    Проверяем качество сигнала (только для ИНФО, НЕ БЛОКИРУЕТ сигнал)
-    """
-    reasons = []
-    atr_percent = (atr / current_price) * 100
-    
-    # 1. ATR проверка
-    if atr_percent < MIN_ATR_PERCENT:
-        reasons.append(f"❌ ATR = {atr_percent:.2f}% (мин. {MIN_ATR_PERCENT}%) → волатильности нет")
-    
-    # 2. H1 зона
-    if direction == "bullish" and h1_zone != "дискаунт":
-        reasons.append(f"❌ Цена в {h1_zone.upper()} → покупать дорого (нужен DISCOUNT)")
-    if direction == "bearish" and h1_zone != "премиум":
-        reasons.append(f"❌ Цена в {h1_zone.upper()} → продавать дёшево (нужен PREMIUM)")
-    
-    # 3. Лондонское направление
-    if london_direction != "range" and london_direction != direction:
-        reasons.append(f"⚠️ Лондон был {london_direction.upper()}, а сигнал {direction.upper()} → возможен разворот")
-    
-    if reasons:
-        return False, reasons
-    return True, []
-
-# =====================
-# 5. ПОЯСНЕНИЯ
-# =====================
-
-def explain_atr(atr_value, current_price, direction):
-    """Объяснение ATR"""
-    volatility_pct = (atr_value / current_price) * 100
-    
-    if volatility_pct < 0.5:
-        level = "🟢 ОЧЕНЬ НИЗКАЯ"
-        comment = "Рынок спит, лучше не входить"
-        color = "🟢"
-    elif volatility_pct < 1.0:
-        level = "🟡 НИЗКАЯ"
-        comment = "Спреды узкие, движение вялое"
-        color = "🟡"
-    elif volatility_pct < 2.0:
-        level = "🟠 СРЕДНЯЯ"
-        comment = "Нормальный рынок, стопы комфортные"
-        color = "🟠"
-    else:
-        level = "🔴 ВЫСОКАЯ"
-        comment = "Осторожно! Возможны резкие движения"
-        color = "🔴"
-    
-    return f"""
-{color} <b>ATR (Средний истинный диапазон) = ${atr_value:.0f}</b>
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-┌─ 📊 Волатильность: {volatility_pct:.2f}% ({level})
-├─ 💡 {comment}
-└─ 📏 1 ATR = {volatility_pct:.2f}% от цены
-
-<b>Как используются уровни ATR:</b>
-   🛑 SL = 1x ATR → {volatility_pct:.2f}%
-   🎯 TP1 = 1.5x ATR → {volatility_pct*1.5:.2f}% (RR 1:1.5)
-   🎯 TP2 = 2.5x ATR → {volatility_pct*2.5:.2f}% (RR 1:2.5)
-   🎯 TP3 = 3.5x ATR → {volatility_pct*3.5:.2f}% (RR 1:3.5)
-
-<b>Что означает ATR = ${atr_value:.0f}:</b>
-   → За последние 14 свечей цена проходила в среднем ${atr_value:.0f}
-   → Если ATR растёт → волатильность увеличивается
-   → Если ATR падает → рынок затихает перед импульсом
-"""
-
-def explain_fvg(fvg_zone, direction, current_price):
-    """Объяснение FVG"""
-    if direction == "bullish":
-        zone_type = "🟢 БЫЧИЙ FVG (Fair Value Gap)"
-        explanation = """Цена резко пошла ВВЕРХ, оставив ценовой разрыв.
-Это зона, куда обычно возвращается цена перед продолжением движения.
-Вход в LONG происходит при возврате в эту зону."""
-        action = "Ждём возврат цены в зону FVG для входа LONG"
-    else:
-        zone_type = "🔴 МЕДВЕЖИЙ FVG (Fair Value Gap)"
-        explanation = """Цена резко пошла ВНИЗ, оставив ценовой разрыв.
-Это зона, куда обычно возвращается цена перед продолжением движения.
-Вход в SHORT происходит при возврате в эту зону."""
-        action = "Ждём возврат цены в зону FVG для входа SHORT"
-    
-    distance = abs(fvg_zone[1] - current_price)
-    
-    return f"""
-{zone_type}
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-┌─ 📍 Верхняя граница: <b>${fvg_zone[1]:.0f}</b>
-├─ 📍 Нижняя граница: <b>${fvg_zone[0]:.0f}</b>
-└─ 📏 Размер зоны: <b>${fvg_zone[1] - fvg_zone[0]:.0f}</b>
-
-<b>📖 Что такое FVG:</b>
-{explanation}
-
-<b>🎯 План входа:</b>
-{action}
-   • Текущая цена: ${current_price:.0f}
-   • Расстояние до зоны: ${distance:.0f}
-"""
-
-def explain_entry_logic(direction, current_price, atr, sl, tp1, tp2, tp3):
-    """Объяснение логики входа"""
-    risk_pct = (abs(current_price - sl) / current_price) * 100
-    reward1_pct = (abs(tp1 - current_price) / current_price) * 100
-    reward3_pct = (abs(tp3 - current_price) / current_price) * 100
-    
-    if direction == "bullish":
-        return f"""
-<b>🎯 ЛОГИКА ВХОДА LONG (покупка)</b>
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-<b>📋 Условия входа (ICT концепции):</b>
-   1️⃣ <b>CHoCH</b> (Change of Character) - смена структуры
-      └── Цена пробила предыдущий High → тренд развернулся вверх
-   
-   2️⃣ <b>MSS</b> (Market Structure Shift) - подтверждение разворота
-      └── Сформирован новый Higher High и Higher Low
-   
-   3️⃣ <b>FVG</b> (Fair Value Gap) - ценовой разрыв
-      └── Ожидаем возврат цены в зону FVG для входа
-
-<b>💰 Уровни сделки:</b>
-   🟢 ENTRY (вход): ${current_price:.0f}
-   🔴 SL (стоп-лосс): ${sl:.0f} (риск {risk_pct:.2f}%)
-   
-   🎯 TP1: ${tp1:.0f} (+{reward1_pct:.2f}%) → закрыть 50%
-   🎯 TP2: ${tp2:.0f} (+{reward1_pct*1.67:.2f}%) → закрыть 30%
-   🎯 TP3: ${tp3:.0f} (+{reward3_pct:.2f}%) → закрыть 20%
-
-<b>📐 Соотношение риск/прибыль:</b>
-   • TP1: 1 : {reward1_pct/risk_pct:.1f}
-   • TP3: 1 : {reward3_pct/risk_pct:.1f}
-"""
-    else:
-        return f"""
-<b>🎯 ЛОГИКА ВХОДА SHORT (продажа)</b>
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-<b>📋 Условия входа (ICT концепции):</b>
-   1️⃣ <b>CHoCH</b> (Change of Character) - смена структуры
-      └── Цена пробила предыдущий Low → тренд развернулся вниз
-   
-   2️⃣ <b>MSS</b> (Market Structure Shift) - подтверждение разворота
-      └── Сформирован новый Lower Low и Lower High
-   
-   3️⃣ <b>FVG</b> (Fair Value Gap) - ценовой разрыв
-      └── Ожидаем возврат цены в зону FVG для входа
-
-<b>💰 Уровни сделки:</b>
-   🟢 ENTRY (вход): ${current_price:.0f}
-   🔴 SL (стоп-лосс): ${sl:.0f} (риск {risk_pct:.2f}%)
-   
-   🎯 TP1: ${tp1:.0f} (-{reward1_pct:.2f}%) → закрыть 50%
-   🎯 TP2: ${tp2:.0f} (-{reward1_pct*1.67:.2f}%) → закрыть 30%
-   🎯 TP3: ${tp3:.0f} (-{reward3_pct:.2f}%) → закрыть 20%
-
-<b>📐 Соотношение риск/прибыль:</b>
-   • TP1: 1 : {reward1_pct/risk_pct:.1f}
-   • TP3: 1 : {reward3_pct/risk_pct:.1f}
-"""
-
-def explain_signal_strength(direction, h4_bias, h1_zone, h4_bias_str):
-    """Объяснение силы ��игнала"""
-    if direction == "bullish":
-        ideal_h4 = "bullish"
-        ideal_h1 = "дискаунт"
-        h4_ok = h4_bias == ideal_h4
-        h1_ok = h1_zone == ideal_h1
-    else:
-        ideal_h4 = "bearish"
-        ideal_h1 = "премиум"
-        h4_ok = h4_bias == ideal_h4
-        h1_ok = h1_zone == ideal_h1
-    
-    text = f"""
-<b>🔍 АНАЛИЗ СИЛЫ СИГНАЛА (H4 + H1)</b>
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-<b>📊 H4 (4-часовой таймфрейм) - тренд:</b>
-   └── Текущий bias: <b>{h4_bias_str}</b>
-   └── Идеал для {direction.upper()}: <b>{ideal_h4.upper()}</b>
-   └── Статус: {'✅ СОВПАДАЕТ' if h4_ok else '❌ НЕ СОВПАДАЕТ'}
-
-<b>📍 H1 (1-часовой таймфрейм) - зона:</b>
-   └── Текущая зона: <b>{h1_zone.upper()}</b>
-   └── Идеал для {direction.upper()}: <b>{ideal_h1.upper()}</b>
-   └── Статус: {'✅ СОВПАДАЕТ' if h1_ok else '❌ НЕ СОВПАДАЕТ'}
-
-<b>📌 ВЕРДИКТ:</b>
-"""
-    if h4_ok and h1_ok:
-        text += """
-   🟢 <b>СИЛЬНЫЙ СИГНАЛ (STRONG)</b>
-   ✅ H4 показывает правильный тренд
-   ✅ H1 даёт хорошую цену для входа
-   🔥 Вероятность успеха - ВЫСОКАЯ
-   📈 Рекомендуемый риск: 1-2% депозита
-"""
-    elif h4_ok:
-        text += """
-   🟡 <b>СРЕДНИЙ СИГНАЛ (MEDIUM)</b>
-   ✅ H4 подтверждает направление
-   ⚠️ H1 зона не идеальна
-   📊 Вероятность успеха - СРЕДНЯЯ
-   📉 Рекомендуемый риск: 0.5-1% депозита
-"""
-    elif h1_ok:
-        text += """
-   🟡 <b>СРЕДНИЙ СИГНАЛ (MEDIUM)</b>
-   ✅ H1 даёт хорошую цену
-   ⚠️ H4 не подтверждает тренд
-   📊 Вероятность успеха - СРЕДНЯЯ
-   📉 Рекомендуемый риск: 0.5-1% депозита
-"""
-    else:
-        text += """
-   🔴 <b>СЛАБЫЙ СИГНАЛ (WEAK)</b>
-   ❌ Ни H4, ни H1 не подтверждают
-   ⚠️ Лучше пропустить сделку
-   📊 Вероятность успеха - НИЗКАЯ
-   💡 Или использовать риск 0.25-0.5%
-"""
-    return text
-
-def explain_session(session):
-    """Объяснение сессии"""
-    sessions = {
-        "АЗИЯ": {
-            "hours": "00:00 - 06:00 UTC",
-            "chars": "🐉 Низкая волатильность, диапазон, ложные пробои",
-            "best_for": "Набор позиций, свинги, осторожная торговля",
-            "ict": "Азиатская сессия - обычно не используется для ICT"
-        },
-        "ЛОНДОН": {
-            "hours": "06:00 - 12:00 UTC",
-            "chars": "🇬🇧 Высокая волатильность, трендовое движение",
-            "best_for": "Лучшее время для ICT стратегий, начало движения",
-            "ict": "Ключевая сессия для определения направления дня"
-        },
-        "НЬЮ-ЙОРК AM": {
-            "hours": "12:00 - 18:00 UTC",
-            "chars": "🇺🇸 Очень высокая волатильность, мощные движения",
-            "best_for": "Продолжение или разворот Лондона, лучшие сигналы",
-            "ict": "Самая важная сессия, пересечение с Лондоном"
-        },
-        "НЬЮ-ЙОРК PM": {
-            "hours": "18:00 - 00:00 UTC",
-            "chars": "🌙 Затишье, коррекции, закрытие позиций",
-            "best_for": "Закрытие позиций, не входить в новые",
-            "ict": "Пост-сессия, низкая ликвидность"
-        }
-    }
-    s = sessions.get(session, sessions["АЗИЯ"])
-    return f"""
-🌍 <b>ТОРГОВАЯ СЕССИЯ: {session}</b>
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-┌─ ⏰ Время: {s['hours']}
-├─ 📊 Характер: {s['chars']}
-├─ 🎯 Лучше всего для: {s['best_for']}
-└─ 📖 ICT: {s['ict']}
-"""
-
-def explain_risk_management(atr, current_price, direction, sl, tp1, tp3):
-    """Объяснение риск-менеджмента"""
-    risk_amount = (abs(current_price - sl) / current_price) * 100
-    reward_tp1 = (abs(tp1 - current_price) / current_price) * 100
-    reward_tp3 = (abs(tp3 - current_price) / current_price) * 100
-    
-    text = f"""
-<b>💰 РИСК-МЕНЕДЖМЕНТ</b>
-━━━━━━━━━━━━━━━━━━━━━━━��━━━━━━━
-
-┌─ 📉 Риск на сделку: <b>{risk_amount:.2f}%</b> депозита
-├─ 📈 Потенциал TP1: <b>+{reward_tp1:.2f}%</b>
-├─ 📈 Потенциал TP3: <b>+{reward_tp3:.2f}%</b>
-├─ 📐 RR TP1: <b>1 : {reward_tp1/risk_amount:.1f}</b>
-└─ 📐 RR TP3: <b>1 : {reward_tp3/risk_amount:.1f}</b>
-
-<b>💡 Пример для депозита $1000:</b>
-   • Риск 1% = $10
-   • Объём позиции = $10 / ${abs(current_price - sl):.0f} = {10/abs(current_price - sl):.5f} BTC
-   • TP1 даст +${reward_tp1/100 * 1000:.0f}
-   • TP3 даст +${reward_tp3/100 * 1000:.0f}
-
-<b>⚠️ ВАЖНЫЕ ПРАВИЛА:</b>
-   1. Никогда не рискуйте больше 2% депозита
-   2. Соблюдайте соотношение RR не менее 1:1.5
-   3. Используйте частичное закрытие (50/30/20)
-   4. Передвигайте SL в безубыток после TP1
-"""
-    return text
-
-def explain_london_ny(london_direction, london_text, ny_model, ny_status):
-    """Объяснение логики Лондон → Нью-Йорк"""
-    return f"""
-<b>🔄 ЛОГИКА LONDON → NEW YORK</b>
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-<b>🇬🇧 ЛОНДОНСКАЯ СЕССИЯ (06:00-12:00 UTC):</b>
-   {london_text}
-
-<b>🇺🇸 НЬЮ-ЙОРК МОДЕЛЬ:</b>
-   {ny_status} {ny_model}
-
-<b>📖 Как это работает:</b>
-   • Лондон задаёт направление дня
-   • Нью-Йорк либо продолжает, либо разворачивает
-   • Модель 1 (продолжение) → сильный сигнал
-   • Модель 2 (разворот) → осторожный сигнал
-"""
-
-# =====================
-# 6. ДАННЫЕ И ИНДИКАТОРЫ
-# =====================
-def fetch_df(exchange, symbol, tf, limit=500):
-    try:
-        data = exchange.fetch_ohlcv(symbol, tf, limit=limit)
-        df = pd.DataFrame(data, columns=['ts', 'o', 'h', 'l', 'c', 'v'])
-        df['ts'] = pd.to_datetime(df['ts'], unit='ms')
-        return df
-    except Exception as e:
-        print(f"Ошибка {symbol} {tf}: {e}")
-        return pd.DataFrame()
-
-def calculate_atr(df, period=14):
-    if len(df) < period:
-        return 0
-    high, low, close = df['h'], df['l'], df['c']
-    tr1 = high - low
-    tr2 = abs(high - close.shift())
-    tr3 = abs(low - close.shift())
-    tr = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
-    return tr.rolling(window=period).mean().iloc[-1]
-
-def get_session():
-    h = datetime.utcnow().hour
-    if 0 <= h < 6:
-        return "АЗИЯ"
-    elif 6 <= h < 12:
-        return "ЛОНДОН"
-    elif 12 <= h < 18:
-        return "НЬЮ-ЙОРК AM"
-    else:
-        return "НЬЮ-ЙОРК PM"
-
-def find_swing_levels(df, lookback=50):
-    if len(df) < lookback:
-        return None, None
-    highs = df['h'].values[-lookback:]
-    lows = df['l'].values[-lookback:]
-    swing_high = None
-    swing_low = None
-    for i in range(2, len(highs) - 2):
-        if (highs[i] > highs[i-1] and highs[i] > highs[i-2] and 
-            highs[i] > highs[i+1] and highs[i] > highs[i+2]):
-            if swing_high is None or highs[i] > swing_high:
-                swing_high = highs[i]
-        if (lows[i] < lows[i-1] and lows[i] < lows[i-2] and 
-            lows[i] < lows[i+1] and lows[i] < lows[i+2]):
-            if swing_low is None or lows[i] < swing_low:
-                swing_low = lows[i]
-    if swing_high is None:
-        swing_high = max(highs)
-    if swing_low is None:
-        swing_low = min(lows)
-    return swing_high, swing_low
-
-def get_h4_bias(h4_high, h4_low):
-    if h4_high is None or h4_low is None:
-        return "RANGE"
-    range_size = (h4_high - h4_low) / h4_low
-    if range_size > 0.05:
-        if h4_high > h4_low * 1.03:
-            return "BULLISH"
-        elif h4_low < h4_high * 0.97:
-            return "BEARISH"
-    return "RANGE"
-
-def get_h1_zone(h1_high, h1_low, current_price):
-    if h1_high is None or h1_low is None:
-        return "unknown", None
-    mid = (h1_high + h1_low) / 2
-    zone = "премиум" if current_price >= mid else "дискаунт"
-    return zone, mid
-
-def mss_bullish(df):
-    if len(df) < 20:
-        return False
-    highs = df['h'].values
-    current_price = df['c'].iloc[-1]
-    for i in range(len(df)-15, len(df)-3):
-        if i < 2:
-            continue
-        if (highs[i] > highs[i-2] and highs[i] > highs[i-1] and 
-            highs[i] > highs[i+1] and highs[i] > highs[i+2]):
-            if current_price > highs[i]:
-                return True
-    return False
-
-def mss_bearish(df):
-    if len(df) < 20:
-        return False
-    lows = df['l'].values
-    current_price = df['c'].iloc[-1]
-    for i in range(len(df)-15, len(df)-3):
-        if i < 2:
-            continue
-        if (lows[i] < lows[i-2] and lows[i] < lows[i-1] and 
-            lows[i] < lows[i+1] and lows[i] < lows[i+2]):
-            if current_price < lows[i]:
-                return True
-    return False
-
-def choch_bullish(df):
-    if len(df) < 10:
-        return False
-    highs = df['h'].values
-    lows = df['l'].values
-    closes = df['c'].values
-    recent_low = min(lows[-5:])
-    previous_low = min(lows[-10:-5])
-    higher_low = recent_low > previous_low
-    recent_high = max(highs[-7:-2])
-    breakout = closes[-1] > recent_high
-    return higher_low and breakout
-
-def choch_bearish(df):
-    if len(df) < 10:
-        return False
-    highs = df['h'].values
-    lows = df['l'].values
-    closes = df['c'].values
-    recent_high = max(highs[-5:])
-    previous_high = max(highs[-10:-5])
-    lower_high = recent_high < previous_high
-    recent_low = min(lows[-7:-2])
-    breakout = closes[-1] < recent_low
-    return lower_high and breakout
-
-def check_smt(df_btc, df_eth):
-    if len(df_btc) < 5 or len(df_eth) < 5:
-        return False, "📡 Нет данных для SMT"
-    btc_high = df_btc['h'].iloc[-5:].max()
-    eth_high = df_eth['h'].iloc[-5:].max()
-    btc_low = df_btc['l'].iloc[-5:].min()
-    eth_low = df_eth['l'].iloc[-5:].min()
-    btc_current = df_btc['c'].iloc[-1]
-    eth_current = df_eth['c'].iloc[-1]
-    btc_new_high = btc_current > btc_high * 0.99
-    eth_new_high = eth_current > eth_high * 0.99
-    btc_new_low = btc_current < btc_low * 1.01
-    eth_new_low = eth_current < eth_low * 1.01
-    
-    if btc_new_high and not eth_new_high:
-        return True, "📡 SMT: BTC делает新高, ETH нет → медвежья дивергенция"
-    if btc_new_low and not eth_new_low:
-        return True, "📡 SMT: BTC делает新低, ETH нет → бычья дивергенция"
-    if eth_new_high and not btc_new_high:
-        return True, "📡 SMT: ETH делает新高, BTC нет → медвежья дивергенция"
-    if eth_new_low and not btc_new_low:
-        return True, "📡 SMT: ETH делает新低, BTC нет → бычья дивергенция"
-    return False, "📡 SMT: нет дивергенции между BTC и ETH"
-
-def check_eth_confirmation(df_btc, df_eth):
-    if len(df_btc) < 20 or len(df_eth) < 20:
-        return False, "🔗 Недостаточно данных для корреляции"
-    btc_returns = df_btc['c'].pct_change().iloc[-20:]
-    eth_returns = df_eth['c'].pct_change().iloc[-20:]
-    correlation = btc_returns.corr(eth_returns)
-    btc_direction = 1 if df_btc['c'].iloc[-1] > df_btc['c'].iloc[-5] else -1
-    eth_direction = 1 if df_eth['c'].iloc[-1] > df_eth['c'].iloc[-5] else -1
-    if correlation > 0.6 and btc_direction == eth_direction:
-        return True, f"🔗 Корреляция с ETH: {correlation:.2f} (сильная, подтверждает)"
-    else:
-        return False, f"🔗 Корреляция с ETH: {correlation:.2f} (слабая, не подтверждает)"
-
-def find_fvg(df, direction='bullish'):
-    if len(df) < 3:
-        return None
-    highs = df['h'].values[-10:]
-    lows = df['l'].values[-10:]
-    closes = df['c'].values[-10:]
-    if direction == 'bullish':
-        for i in range(2, len(closes)-1):
-            if closes[i] > highs[i-1] and lows[i] > highs[i-2]:
-                return (highs[i-2], lows[i])
-    else:
-        for i in range(2, len(closes)-1):
-            if closes[i] < lows[i-1] and highs[i] < lows[i-2]:
-                return (lows[i-2], highs[i])
-    return None
-
-# =====================
-# 7. ОСНОВНОЙ АНАЛИЗ
-# =====================
-def analyze_and_signal():
-    now = datetime.utcnow()
-    current_candle_time = now.replace(minute=(now.minute // 15) * 15, second=0, microsecond=0)
-    print(f"\n[{now.strftime('%Y-%m-%d %H:%M:%S')} UTC] 🔍 Проверка сигналов...")
-
-    # Проверка дня
-    trade_day_ok, trade_day_msg = is_trade_day()
-    if not trade_day_ok:
-        print(f"⏰ {trade_day_msg}")
-        return
-
-    session = get_session()
-    # Торгуем во всех сессиях, кроме АЗИЯ
-    if session not in ["ЛОНДОН", "НЬЮ-ЙОРК AM", "НЬЮ-ЙОРК PM"]:
-        print(f"⏰ Пропускаем ({session})")
-        return
-
-    try:
-        exchange = ccxt.htx({
-            'enableRateLimit': True,
-            'options': {'defaultType': 'spot'},
-            'timeout': 30000
-        })
-    except Exception as e:
-        print(f"❌ Ошибка подключения: {e}")
-        return
-
-    print("📊 Загрузка данных...")
-    df_h4 = fetch_df(exchange, BASE_SYMBOL, '4h', limit=100)
-    df_h1 = fetch_df(exchange, BASE_SYMBOL, '1h', limit=100)
-    df_m15 = fetch_df(exchange, BASE_SYMBOL, '15m', limit=300)
-    df_m5 = fetch_df(exchange, BASE_SYMBOL, '5m', limit=500)
-    df_eth = fetch_df(exchange, CONFIRM_SYMBOL, '15m', limit=100)
-
-    if df_m5.empty or df_m15.empty:
-        print("❌ Нет данных")
-        return
-
-    current_price = df_m5['c'].iloc[-1]
-    print(f"💰 BTC: ${current_price:.0f}")
-
-    # Лондонская сессия (только сегодняшняя)
-    london_direction, london_text = get_london_direction(df_m5)
-    print(f"🇬🇧 {london_text}")
-
-    # Нью-Йорк модель (только сегодняшняя)
-    ny_model = ""
-    ny_status = ""
-    if session in ["НЬЮ-ЙОРК AM", "НЬЮ-ЙОРК PM"]:
-        ny_model, ny_status = get_ny_model(london_direction, df_m5)
-        print(f"🇺🇸 NY модель: {ny_model}")
-
-    # Сигналы MSS и CHoCH
-    mss_bull = mss_bullish(df_m15)
-    mss_bear = mss_bearish(df_m15)
-    choch_bull = choch_bullish(df_m5)
-    choch_bear = choch_bearish(df_m5)
-
-    direction = None
-    if mss_bull and choch_bull:
-        direction = "bullish"
-    elif mss_bear and choch_bear:
-        direction = "bearish"
-
-    if not direction:
-        print("📊 Нет сигнала MSS+CHoCH")
-        return
-
-    print(f"📈 Направление: {direction.upper()}")
-
-    # SMT и корреляция
-    smt_yes, smt_msg = check_smt(df_m15, df_eth)
-    eth_conf, eth_msg = check_eth_confirmation(df_m15, df_eth)
-
-    # H4 и H1
-    h4_high, h4_low = find_swing_levels(df_h4, 50)
-    h1_high, h1_low = find_swing_levels(df_h1, 50)
-
-    h4_bias_str = get_h4_bias(h4_high, h4_low)
-    h1_zone, h1_mid = get_h1_zone(h1_high, h1_low, current_price)
-
-    if h4_bias_str == "BULLISH":
-        h4_bias = "bullish"
-    elif h4_bias_str == "BEARISH":
-        h4_bias = "bearish"
-    else:
-        h4_bias = "range"
-
-    # Проверка нового сигнала
-    last_signal = load_last_signal()
-    current_signal = {
-        "direction": direction,
-        "h4_bias": h4_bias,
-        "h1_zone": h1_zone,
-        "candle_time": current_candle_time.isoformat()
-    }
-    
-    if not is_new_signal(current_signal, last_signal):
-        print(f"📭 Сигнал не новый")
-        return
-    
-    print(f"🆕 НОВЫЙ СИГНАЛ!")
-
-    # ATR и уровни
-    atr = calculate_atr(df_m5, 14)
-    if atr == 0:
-        atr = current_price * 0.005
-
-    if direction == "bullish":
-        sl = current_price - atr * 1.0
-        tp1 = current_price + atr * 1.5
-        tp2 = current_price + atr * 2.5
-        tp3 = h1_high if h1_high else current_price + atr * 3.5
-        entry = current_price
-    else:
-        sl = current_price + atr * 1.0
-        tp1 = current_price - atr * 1.5
-        tp2 = current_price - atr * 2.5
-        tp3 = h1_low if h1_low else current_price - atr * 3.5
-        entry = current_price
-
-    # Фильтр качества - ТОЛЬКО ДЛЯ ИНФО, НЕ БЛОКИРУЕТ СИГНАЛ
-    quality_ok, quality_reasons = is_quality_signal(
-        direction, atr, current_price, h4_bias, h1_zone, london_direction
-    )
-
-    # FVG
-    fvg_zone = find_fvg(df_m5, direction)
-    if not fvg_zone:
-        if direction == "bullish":
-            fvg_zone = (current_price - atr*0.5, current_price)
-        else:
-            fvg_zone = (current_price, current_price + atr*0.5)
-
-    # Сильный сигнал?
-    strong = False
-    if direction == "bullish" and h4_bias == "bullish" and h1_zone == "дискаунт":
-        strong = True
-    elif direction == "bearish" and h4_bias == "bearish" and h1_zone == "премиум":
-        strong = True
-
-    # ========== ФОРМИРУЕМ ПОЛНОЕ СООБЩЕНИЕ ==========
-    
-    header = f"""
-{'🟢' if strong else '📊'} <b>ICT SETUP {BASE_SYMBOL}</b>
-{'🔥 СИЛЬНЫЙ СИГНАЛ 🔥' if strong else 'ИНФОРМАЦИОННЫЙ СИГНАЛ'}
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-"""
-    
-    basic_info = f"""
-<b>📌 НАПРАВЛЕНИЕ:</b> {'📈 LONG (покупка)' if direction == 'bullish' else '📉 SHORT (продажа)'}
-<b>💰 ТЕКУЩАЯ ЦЕНА:</b> ${current_price:.0f}
-<b>🎯 ТОРГОВАЯ СЕССИЯ:</b> {session}
-{trade_day_msg}
-"""
-    
-    # ATR пояснение
-    atr_explanation = explain_atr(atr, current_price, direction)
-    
-    # FVG пояснение
-    fvg_explanation = explain_fvg(fvg_zone, direction, current_price)
-    
-    # Уровни
-    levels = f"""
-<b>📊 УРОВНИ ВХОДА И ВЫХОДА</b>
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-┌─ 🟢 ENTRY (лимитный ордер): <b>${entry:.0f}</b>
-├─ 🔴 SL (стоп-лосс): <b>${sl:.0f}</b>
-├─ 🎯 TP1: <b>${tp1:.0f}</b> → закрыть 50% позиции
-├─ 🎯 TP2: <b>${tp2:.0f}</b> → закрыть 30% позиции
-└─ 🎯 TP3: <b>${tp3:.0f}</b> → закрыть 20% позиции
-"""
-    
-    # Логика входа
-    entry_logic = explain_entry_logic(direction, current_price, atr, sl, tp1, tp2, tp3)
-    
-    # Сила сигнала
-    strength_analysis = explain_signal_strength(direction, h4_bias, h1_zone, h4_bias_str)
-    
-    # Лондон → Нью-Йорк
-    london_ny = explain_london_ny(london_direction, london_text, ny_model, ny_status) if session in ["НЬЮ-ЙОРК AM", "НЬЮ-ЙОРК PM"] else ""
-    
-    # Дополнительные факторы
-    extra_factors = f"""
-<b>📡 ДОПОЛНИТЕЛЬНЫЕ ФАКТОРЫ</b>
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-{smt_msg}
-{eth_msg}
-"""
-    
-    # Фильтр качества (только инфо, не блокирует)
-    quality_warning = ""
-    if not quality_ok:
-        quality_warning = f"""
-<b>⚠️ ФИЛЬТР КАЧЕСТВА НЕ ПРОЙДЕН (НО СИГНАЛ ОТПРАВЛЕН)</b>
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-{chr(10).join(quality_reasons)}
-
-💡 <b>Рекомендация:</b> Входить с осторожностью или уменьшить риск
-"""
-    
-    # Риск-менеджмент
-    risk_management = explain_risk_management(atr, current_price, direction, sl, tp1, tp3)
-    
-    # Сессия
-    session_info = explain_session(session)
-    
-    # Время
-    time_info = f"""
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-🕐 {now.strftime('%d.%m.%Y %H:%M')} UTC
-⚠️ <b>Не является финансовой рекомендацией</b>
-"""
-    
-    # Собираем всё
-    full_message = (
-        header + basic_info + atr_explanation + fvg_explanation + levels + 
-        entry_logic + strength_analysis + london_ny + extra_factors + 
-        quality_warning + risk_management + session_info + time_info
-    )
-    
-    # Отправляем
-    send_telegram(full_message)
-    
-    # Сильный сигнал - краткая версия
-    if strong:
-        strong_message = f"""
-🟢 <b>🔥 СИЛЬНЫЙ СИГНАЛ {BASE_SYMBOL}</b>
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-<b>📌 Направление:</b> {'📈 LONG' if direction == 'bullish' else '📉 SHORT'}
-<b>💰 Цена:</b> ${current_price:.0f}
-
-<b>УРОВНИ:</b>
-┌─ 🟢 ENTRY: ${entry:.0f}
-├─ 🔴 SL: ${sl:.0f}
-├─ 🎯 TP1: ${tp1:.0f}
-├─ 🎯 TP2: ${tp2:.0f}
-└─ 🎯 TP3: ${tp3:.0f}
-
-<b>✅ СОВПАДАЕТ:</b>
-   • H4: {h4_bias_str}
-   • H1: {h1_zone.upper()}
-
-{london_text}
-
-{smt_msg}
-
-📐 RR TP3: {(abs(tp3 - current_price)/abs(current_price - sl)):.1f}:1
-
-🕐 {now.strftime('%H:%M')} UTC
-"""
-        send_telegram(strong_message)
-    
-    # Сохраняем сигнал
-    save_last_signal(current_signal)
-    
-    # Сохраняем сделку - ВСЕГДА, если есть сигнал
-    state = load_state()
-    if not state["active"]:
-        state["active"] = True
-        state["direction"] = direction
-        state["entry"] = entry
-        state["sl"] = sl
-        state["tp1"] = tp1
-        state["tp2"] = tp2
-        state["tp3"] = tp3
-        state["entered"] = False
-        state["tp1_hit"] = False
-        state["tp2_hit"] = False
-        state["tp3_hit"] = False
-        state["sl_hit"] = False
-        save_state(state)
-        print("📝 Новая сделка сохранена")
-
-# =====================
-# 8. СОПРОВОЖДЕНИЕ СДЕЛКИ
-# =====================
-def check_entry_and_targets():
-    state = load_state()
-    if not state["active"]:
-        return
-
-    try:
-        exchange = ccxt.htx({'enableRateLimit': True, 'timeout': 30000})
-        df_m5 = fetch_df(exchange, BASE_SYMBOL, '5m', limit=10)
-        if df_m5.empty:
-            return
-        current_price = df_m5['c'].iloc[-1]
-    except Exception as e:
-        print(f"Ошибка получения цены: {e}")
-        return
-
-    direction = state["direction"]
-    entry = state["entry"]
-    sl = state["sl"]
-    tp1 = state["tp1"]
-    tp2 = state["tp2"]
-    tp3 = state["tp3"]
-
-    if not state["entered"]:
-        if direction == "bullish" and current_price <= entry:
-            send_telegram(f"""
-🔔 <b>ENTRY LONG {BASE_SYMBOL}</b>
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-<b>✅ Цена вошла в зону FVG!</b>
-
-💰 Цена входа: ${current_price:.0f}
-🛑 SL: ${sl:.0f}
-🎯 TP1: ${tp1:.0f}
-🎯 TP2: ${tp2:.0f}
-🎯 TP3: ${tp3:.0f}
-
-📊 Риск: {abs(current_price - sl)/current_price*100:.2f}%
-📈 RR TP1: {abs(tp1 - current_price)/abs(current_price - sl):.1f}:1
-""")
-            state["entered"] = True
-            save_state(state)
-        elif direction == "bearish" and current_price >= entry:
-            send_telegram(f"""
-🔔 <b>ENTRY SHORT {BASE_SYMBOL}</b>
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-<b>✅ Цена вошла в зону FVG!</b>
-
-💰 Цена входа: ${current_price:.0f}
-🛑 SL: ${sl:.0f}
-🎯 TP1: ${tp1:.0f}
-🎯 TP2: ${tp2:.0f}
-🎯 TP3: ${tp3:.0f}
-
-📊 Риск: {abs(current_price - sl)/current_price*100:.2f}%
-📈 RR TP1: {abs(tp1 - current_price)/abs(current_price - sl):.1f}:1
-""")
-            state["entered"] = True
-            save_state(state)
-
-    if not state["sl_hit"]:
-        if (direction == "bullish" and current_price <= sl) or (direction == "bearish" and current_price >= sl):
-            send_telegram(f"""
-❌ <b>SL HIT {BASE_SYMBOL}</b>
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-💰 Цена: ${current_price:.0f}
-🛑 Стоп-лосс: ${sl:.0f}
-
-<b>Причина:</b> Структура рынка сломана
-
-{stats_text(state)}
-""")
-            state["sl_hit"] = True
-            state["active"] = False
-            state["losses"] += 1
-            save_state(state)
-            return
-
-    if not state["tp1_hit"]:
-        if (direction == "bullish" and current_price >= tp1) or (direction == "bearish" and current_price <= tp1):
-            send_telegram(f"""
-🎯 <b>TP1 HIT {BASE_SYMBOL}</b>
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-💰 Цена: ${current_price:.0f}
-📊 Закрыто: 50% позиции
-
-✅ Остаток позиции: 50%
-🎯 Следующая цель: TP2 (${tp2:.0f})
-""")
-            state["tp1_hit"] = True
-            save_state(state)
-
-    if not state["tp2_hit"]:
-        if (direction == "bullish" and current_price >= tp2) or (direction == "bearish" and current_price <= tp2):
-            send_telegram(f"""
-🎯 <b>TP2 HIT {BASE_SYMBOL}</b>
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-💰 Цена: ${current_price:.0f}
-📊 Закрыто: 30% позиции
-
-✅ Остаток позиции: 20%
-🎯 Следующая цель: TP3 (${tp3:.0f})
-""")
-            state["tp2_hit"] = True
-            save_state(state)
-
-    if not state["tp3_hit"]:
-        if (direction == "bullish" and current_price >= tp3) or (direction == "bearish" and current_price <= tp3):
-            send_telegram(f"""
-🏆 <b>TP3 HIT {BASE_SYMBOL}</b>
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-💰 Цена: ${current_price:.0f}
-📊 Сделка полностью закрыта!
-
-✅ Прибыль зафиксирована
-{stats_text(state)}
-""")
-            state["tp3_hit"] = True
-            state["active"] = False
-            state["wins"] += 1
-            save_state(state)
-            return
-
-# =====================
-# 9. ОСНОВНОЙ ЦИКЛ
-# =====================
-def main_loop():
-    send_telegram("""
-✅ <b>ICT Trading Bot v5.0 ЗАПУЩЕН!</b>
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-📌 <b>Режим работы:</b>
-   • Проверка каждые 15 минут
-   • Отправка только при НОВЫХ сигналах
-   • Торговые сессии: ЛОНДОН, НЬЮ-ЙОРК AM, НЬЮ-ЙОРК PM
-
-📊 <b>Фильтры качества:</b>
-   • Неторговые дни: ПН, ВС
-   • Минимальный ATR: 0.5%
-   • Проверка H4 + H1 контекста
-
-🎯 <b>Риск-менеджмент:</b>
-   • TP1/TP2/TP3 с частичным закрытием
-   • Соотношение RR от 1:1.5
-
-📖 <b>В сообщениях будут пояснения:</b>
-   • Что такое ATR и как его использовать
-   • Что такое FVG и где вход
-   • Почему сильный или слабый сигнал
-   • Логика London → NY
-""")
-    
-    state = load_state()
-    print(f"📊 {stats_text(state)}")
-    
-    last_candle_time = None
-    
-    while True:
-        now = datetime.utcnow()
-        current_candle = now.replace(minute=(now.minute // 15) * 15, second=0, microsecond=0)
-        
-        if last_candle_time != current_candle and now.second > 30:
-            last_candle_time = current_candle
-            print(f"\n{'='*50}")
-            print(f"[{now.strftime('%Y-%m-%d %H:%M:%S')}] 🕯 Закрылась 15M свеча")
-            
-            analyze_and_signal()
-            check_entry_and_targets()
-            
-            state = load_state()
-            print(f"📊 {stats_text(state)}")
-        
-        time.sleep(30)
-
-# =====================
-# 10. ЗАПУСК
-# =====================
-if __name__ == "__main__":
-    try:
-        main_loop()
-    except KeyboardInterrupt:
-        print("\n👋 Бот остановлен")
-        sys.exit(0)
-    except Exception as e:
-        print(f"❌ Ошибка: {e}")
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)
+1