Update app.py

app.py

@@ -36,6 +36,17 @@ EXCHANGE_RETRY_ATTEMPTS = 3          # Кол-во повторных попыт
 EXCHANGE_RETRY_DELAY_SEC = 1.5       # Базовая задержка между повторными попытками (экспоненциально растет)
 RSI_BOTTOM_LOOKBACK     = 5          # Окно свечей для поиска локального дна RSI
 
+# ── Авто-бэкофф скринера при сетевых сбоях ──
+# SCREENER_INTERVAL_SEC=90 + CANDLE_FETCH_BATCH_SIZE=55 дают до ~165 запросов свечей за один скрин
+# (3 таймфрейма x 55 монет) плюс fetch_tickers - на коротком интервале это ощутимо чаще бьет по
+# рейт-лимитам биржи, чем было при 300 сек. Вместо того чтобы просто зашить более длинный интервал
+# (что убьет смысл ускорения входов), бот сам временно увеличивает интервал скрина, если видит
+# всплеск сетевых ошибок/рейт-лимитов от safe_call, и возвращается к нормальному интервалу,
+# когда сеть/лимиты снова спокойны.
+SCREENER_ERROR_WINDOW_SEC      = 300   # Окно, за которое считаем недавние сетевые ошибки
+SCREENER_ERROR_BACKOFF_THRESHOLD = 5   # Сколько ошибок в окне триггерят бэкофф
+SCREENER_BACKOFF_MULTIPLIER    = 3     # Во сколько раз увеличиваем интервал скрина во время бэкоффа
+
 # ── Авто-масштабирование слотов по росту депозита ──
 SLOT_SCALING_TABLE = [
     (20,    5),
@@ -225,6 +236,10 @@ class BotState:
         self.grading_budget     = 0.0            # Отдельный бюджет под режим градации (не пересекается с total_budget портфеля)
         self.grading_positions: dict[str, dict]  = {}  # symbol -> {"rolling_high", "filled": set(), "qty", "cost"}
 
+        # ── Авто-бэкофф скринера при всплеске сетевых ошибок ──
+        self._network_error_lock = threading.Lock()
+        self.recent_network_errors: list[float] = []  # метки времени недавних сетевых ошибок (для скользящего окна)
+
     def budget_per_slot(self) -> float:
         if self.num_slots <= 0:
             return 0.0
@@ -263,6 +278,32 @@ class BotState:
     def occupied_symbols(self) -> set[str]:
         return {s.symbol for s in self.slots if s.symbol is not None}
 
+    def register_network_error(self):
+        """Фиксирует метку времени сетевой ошибки биржи (вызывается из safe_call).
+        Используется для авто-бэкоффа интервала скринера при всплеске сбоев/рейт-лимитов."""
+        now = time.time()
+        with self._network_error_lock:
+            self.recent_network_errors.append(now)
+            cutoff = now - SCREENER_ERROR_WINDOW_SEC
+            self.recent_network_errors = [t for t in self.recent_network_errors if t >= cutoff]
+
+    def effective_screener_interval(self) -> float:
+        """
+        Возвращает интервал между полными скринами рынка: обычно SCREENER_INTERVAL_SEC,
+        но временно увеличенный в SCREENER_BACKOFF_MULTIPLIER раз, если за последние
+        SCREENER_ERROR_WINDOW_SEC секунд накопилось SCREENER_ERROR_BACKOFF_THRESHOLD+ сетевых
+        ошибок - защита от того, чтобы частый скрин (много запросов свечей за короткий интервал)
+        не долбил биржу еще сильнее, когда она уже отвечает сбоями/рейт-лимитами.
+        """
+        now = time.time()
+        with self._network_error_lock:
+            cutoff = now - SCREENER_ERROR_WINDOW_SEC
+            self.recent_network_errors = [t for t in self.recent_network_errors if t >= cutoff]
+            error_count = len(self.recent_network_errors)
+        if error_count >= SCREENER_ERROR_BACKOFF_THRESHOLD:
+            return SCREENER_INTERVAL_SEC * SCREENER_BACKOFF_MULTIPLIER
+        return SCREENER_INTERVAL_SEC
+
     def save_persisted_state(self):
         """
         Сохраняет слоты, статистику И параметры торговли на диск + асинхронно в публичный
@@ -293,6 +334,18 @@ class BotState:
                 "strategy_engine": self.strategy_engine,
                 "grading_symbols": self.grading_symbols,
                 "grading_budget": self.grading_budget,
+                # "filled" внутри позиции - это set(), json не умеет его сериализовать напрямую,
+                # поэтому конвертируем в list только на момент сохранения (см. load_from_dict-аналог
+                # при восстановлении - reconcile_persisted_grading конвертирует list обратно в set).
+                "grading_positions": {
+                    sym: {
+                        "rolling_high": pos.get("rolling_high", 0.0),
+                        "filled": sorted(pos.get("filled", set())),
+                        "qty": pos.get("qty", 0.0),
+                        "cost": pos.get("cost", 0.0),
+                    }
+                    for sym, pos in self.grading_positions.items()
+                },
                 "auto_scale_slots": self.auto_scale_slots,
                 "proxy_url": self.proxy_url,
                 "total_profit": self.total_profit,
@@ -460,6 +513,7 @@ def safe_call(fn, *args, state: "BotState | None" = None, label: str = "exchange
             last_err = e
             if state:
                 state.log(f"{label}: временная ошибка сети (попытка {attempt}/{EXCHANGE_RETRY_ATTEMPTS}): {e}", "WARN")
+                state.register_network_error()  # авто-бэкофф скринера при накоплении таких ошибок
             time.sleep(EXCHANGE_RETRY_DELAY_SEC * attempt)
         except ccxt.ExchangeError as e:
             # Ошибки биржи (неверные параметры, отклоненный ордер и т.п.) ретраить бессмысленно - пробрасываем сразу
@@ -873,6 +927,35 @@ def screen_full_market(
 
     candidates.sort(key=lambda x: x["vol"], reverse=True)
     batch = candidates[:CANDLE_FETCH_BATCH_SIZE]
+
+    # ── Принудительное включение "самой просевшей" монеты ──
+    # Обычный батч режется по топ-CANDLE_FETCH_BATCH_SIZE по ОБЪЕМУ, поэтому монета с рекордной
+    # просадкой от суточного хая, но за пределами этого топа по объему, раньше вообще не доходила
+    # до анализа индикаторами и не могла попасть в scored, даже если по факту сильнее всех просела.
+    # Здесь ищем такую монету среди ВСЕХ кандидатов, прошедших базовый фильтр объема/спреда
+    # (а не только среди топ-N по объему), и добавляем её в батч на анализ, если она там еще не
+    # присутствует. Это НЕ обходит фильтры входа (дивергенция/RSI/Боллинджер, адаптивная просадка) -
+    # монета все равно должна пройти is_entry_triggered ниже, просто ей гарантированно дают шанс.
+    most_dropped = None
+    best_drawdown_24h = -1.0
+    for c in candidates:
+        high_24h = c["high_24h"]
+        if high_24h <= 0:
+            continue
+        drawdown_24h = (high_24h - c["ask"]) / high_24h
+        if drawdown_24h > best_drawdown_24h:
+            best_drawdown_24h = drawdown_24h
+            most_dropped = c
+
+    batch_symbols = {c["symbol"] for c in batch}
+    if most_dropped is not None and most_dropped["symbol"] not in batch_symbols:
+        batch = batch + [most_dropped]
+        state.log(
+            f"📉 Принудительно добавлена в анализ самая просевшая монета вне топа по объему: "
+            f"{most_dropped['symbol']} (просадка от суточного хая {best_drawdown_24h*100:.2f}%)",
+            "INFO"
+        )
+
     state.log(f"Анализируем индикаторами топ-{len(batch)} по объему", "INFO")
 
     scored: list[dict] = []
@@ -1527,6 +1610,83 @@ def reconcile_persisted_slots(exchange: ccxt.binance, state: BotState):
     state.save_persisted_state()
 
 
+def reconcile_persisted_grading(exchange: ccxt.binance, state: BotState):
+    """
+    Восстанавливает state.grading_positions (лесенка "Градации") из сохраненного состояния -
+    до этого исправления оно вообще не переживало рестарт контейнера, из-за чего после редеплоя
+    бот "забывал" про уже заполненные грейды и в Live рисковал докупать те же уровни повторно.
+
+    В paper-режиме восстанавливаем как есть (виртуальный учет, бирже нечего сверять).
+    В Live - сверяем накопленное qty по каждой монете с реальным балансом на бирже: если на
+    балансе заметно меньше, чем должно быть по записи, считаем позицию по этой монете закрытой
+    вручную/устаревшей и НЕ восстанавливаем ее (безопаснее начать грейдацию с нуля от нового
+    скользящего хая, чем рисковать задвоением докупок поверх уже не существующей позиции).
+    """
+    saved = state.load_persisted_state()
+    if not saved:
+        return
+
+    if saved.get("paper_trading") != state.paper_trading:
+        state.log(
+            "Персистентность Градации: сохраненное состояние относится к другому режиму (paper/live) - "
+            "восстановление ПРОПУЩЕНО ради безопасности", "WARN"
+        )
+        return
+
+    saved_grading = saved.get("grading_positions", {})
+    if not saved_grading:
+        return
+
+    restored_n = 0
+    for sym, sdict in saved_grading.items():
+        qty = float(sdict.get("qty", 0.0))
+        cost = float(sdict.get("cost", 0.0))
+        rolling_high = float(sdict.get("rolling_high", 0.0))
+        filled = set(sdict.get("filled", []))
+
+        if qty <= 0:
+            continue  # позиции по монете не было на момент сохранения - восстанавливать нечего
+
+        if state.paper_trading:
+            state.grading_positions[sym] = {
+                "rolling_high": rolling_high, "filled": filled, "qty": qty, "cost": cost,
+            }
+            restored_n += 1
+            continue
+
+        # ── Live: сверяем накопленное qty с реальным балансом на бирже ──
+        try:
+            base = sym.split("/")[0]
+            balance = safe_call(exchange.fetch_balance, state=state, label=f"grading reconcile {base}")
+            qty_total = float(balance.get("total", {}).get(base, 0) or 0)
+        except Exception as e:
+            state.log(
+                f"Градация {sym}: сверка после рестарта - ошибка баланса {e}, позиция НЕ восстановлена (безопасность)",
+                "ERR"
+            )
+            continue
+
+        if qty_total < qty * 0.9:
+            state.log(
+                f"Градация {sym}: сверка после рестарта - на балансе {qty_total:.6g}, а по записи "
+                f"должно быть ~{qty:.6g} - позиция закрыта помимо бота. Грейды сброшены, старт с чистого листа.",
+                "WARN"
+            )
+            continue
+
+        state.grading_positions[sym] = {
+            "rolling_high": rolling_high, "filled": filled, "qty": qty, "cost": cost,
+        }
+        restored_n += 1
+        state.log(
+            f"♻️ Градация {sym}: восстановлено {len(filled)} грейдов после рестарта, "
+            f"qty={qty:.6g} подтверждено на балансе", "OK"
+        )
+
+    if restored_n:
+        state.log(f"♻️ Персистентность Градации: восстановлено позиций по {restored_n} монете(ам)", "OK")
+
+
 def trading_loop(state: BotState):
     state.log(f"Торговый цикл запущен — портфель из {state.num_slots} слотов, бюджет ${state.total_budget}", "INFO")
     if state.paper_trading:
@@ -1546,6 +1706,10 @@ def trading_loop(state: BotState):
         # их с реальным балансом на бирже (актуально в первую очередь для Live)
         reconcile_persisted_slots(exchange, state)
 
+        # Восстанавливаем позиции режима "Градация" (лесенка по крупным монетам) - до этого
+        # исправления они вообще не переживали рестарт контейнера (см. reconcile_persisted_grading)
+        reconcile_persisted_grading(exchange, state)
+
         per_slot = state.budget_per_slot()
         if per_slot * 1.001 < 1.0:
             state.log(
@@ -1625,10 +1789,16 @@ def trading_loop(state: BotState):
 
             if empty_slots:
                 now = time.time()
-                should_screen = (now - state.last_full_screen_at >= SCREENER_INTERVAL_SEC) or any(
+                current_interval = state.effective_screener_interval()
+                should_screen = (now - state.last_full_screen_at >= current_interval) or any(
                     s.last_refill_attempt == 0.0 for s in empty_slots
                 )
                 if should_screen:
+                    if current_interval > SCREENER_INTERVAL_SEC:
+                        state.log(
+                            f"⚠️ Авто-��экофф скринера активен: интервал временно увеличен до {current_interval:.0f}с "
+                            f"из-за недавних сетевых ошибок/рейт-лимитов", "WARN"
+                        )
                     state.last_full_screen_at = now
                     refill_empty_slots(exchange, allowed_symbols, empty_slots, state)
 
@@ -1636,7 +1806,7 @@ def trading_loop(state: BotState):
             if occupied_n == state.num_slots:
                 state.status = f"🟢 Портфель полон ({occupied_n}/{state.num_slots})"
             elif occupied_n == 0:
-                wait_left = max(0, int(SCREENER_INTERVAL_SEC - (time.time() - state.last_full_screen_at)))
+                wait_left = max(0, int(state.effective_screener_interval() - (time.time() - state.last_full_screen_at)))
                 state.status = f"🔍 Поиск ({occupied_n}/{state.num_slots}) · след. скрин ~{wait_left}с"
             else:
                 state.status = f"🟡 Частично занят ({occupied_n}/{state.num_slots})"