Update app.py

app.py

@@ -50,9 +50,67 @@ SLOT_SCALING_TABLE = [
 AUTOSCALE_CHECK_INTERVAL_SEC = 3600   # Проверять реальный баланс раз в час (не смысла чаще - депозит не растет каждую минуту)
 SYMBOLS_REFRESH_INTERVAL_SEC = 3600   # Раз в час пересчитывать список разрешенных пар под текущий бюджет/слот
 
-# ── Персистентность состояния слотов на диск (переживает рестарт процесса/контейнера,
-# НЕ переживает полный редеплой с чистого образа - там нужна внешняя БД/volume) ──
+# ── Персистентность состояния слотов на диск + приватный HF Dataset ──
+# Локальный диск переживает обычный рестарт процесса, но НЕ переживает полный редеплой
+# HF Spaces "с нуля" (там пересоздается вся файловая система). Поэтому дополнительно
+# состояние зеркалируется в приватный HF Dataset - это переживает ЛЮБОЙ рестарт контейнера,
+# включая пересоздание образа, т.к. датасет живет отдельно от самого Space.
 STATE_FILE_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "gvp_scalper_state.json")
+STATE_FILENAME_IN_REPO = "gvp_scalper_state.json"
+HF_TOKEN = os.environ.get("HF_TOKEN", "")
+HF_DATASET_ID = os.environ.get("HF_DATASET_ID", "")
+
+
+def _hf_dataset_configured() -> bool:
+    return bool(HF_TOKEN and HF_DATASET_ID)
+
+
+def _push_state_to_hf_dataset(local_path: str):
+    """
+    Асинхронно (в отдельном daemon-потоке) заливает файл состояния в приватный HF Dataset.
+    Намеренно НЕ блокирует торговый поток - сетевой запрос к серверам HF может занять
+    секунды, а сохранение состояния вызывается часто (после каждой сделки).
+    Если HF_TOKEN/HF_DATASET_ID не заданы в Секретах Space - тихо ничего не делает.
+    """
+    if not _hf_dataset_configured():
+        return
+
+    def _upload():
+        try:
+            from huggingface_hub import HfApi
+            api = HfApi(token=HF_TOKEN)
+            # exist_ok=True - безопасно дергать при КАЖДОЙ заливке, датасет создается
+            # автоматически только один раз, при первом реальном запуске
+            api.create_repo(repo_id=HF_DATASET_ID, repo_type="dataset", private=True, exist_ok=True)
+            api.upload_file(
+                path_or_fileobj=local_path,
+                path_in_repo=STATE_FILENAME_IN_REPO,
+                repo_id=HF_DATASET_ID,
+                repo_type="dataset",
+            )
+        except Exception as e:
+            logging.warning(f"HF Dataset: не удалось залить состояние - {e}")
+
+    threading.Thread(target=_upload, daemon=True).start()
+
+
+def _pull_state_from_hf_dataset() -> str | None:
+    """
+    Скачивает файл состояния из приватного HF Dataset. Возвращает ЛОКАЛЬНЫЙ путь к скачанному
+    файлу (huggingface_hub кэширует его на диск) или None, если датасет не настроен, либо
+    файла там еще нет - это нормальная ситуация при самом первом запуске, падать нельзя.
+    """
+    if not _hf_dataset_configured():
+        return None
+    try:
+        from huggingface_hub import hf_hub_download
+        return hf_hub_download(
+            repo_id=HF_DATASET_ID, repo_type="dataset",
+            filename=STATE_FILENAME_IN_REPO, token=HF_TOKEN,
+        )
+    except Exception as e:
+        logging.info(f"HF Dataset: файл состояния не найден/недоступен ({e}) - считаем первым запуском")
+        return None
 
 # ── Стратегия "Градация" - крупные высоколиквидные монеты, лесенка докупок на просадке ──
 GRADING_DEFAULT_SYMBOLS   = ["BTC/USDT", "ETH/USDT", "BNB/USDT", "SOL/USDT"]
@@ -77,6 +135,7 @@ class Slot:
     target_profit_set: float = 0.05     # Целевая прибыль, рассчитанная для конкретной сделки
     status: str = "🔍 Поиск"            # Отображаемый статус
     last_refill_attempt: float = 0.0    # Метка времени для анти-спама
+    last_known_price: float = 0.0       # Последняя увиденная рыночная цена (для о��ображения незафиксированного P&L)
 
     def is_empty(self) -> bool:
         return self.symbol is None
@@ -91,6 +150,7 @@ class Slot:
         self.usdt_spent = 0.0
         self.target_profit_set = 0.05
         self.status = "🔍 Поиск"
+        self.last_known_price = 0.0
 
     def to_dict(self) -> dict:
         """Сериализация слота для сохранения на диск (datetime -> ISO-строка)."""
@@ -112,6 +172,7 @@ class Slot:
         self.target_profit_set = float(d.get("target_profit_set", 0.05))
         self.status = d.get("status", "🔍 Поиск")
         self.last_refill_attempt = float(d.get("last_refill_attempt", 0.0))
+        self.last_known_price = float(d.get("last_known_price", 0.0))
 
 
 # ─────────────────────────────────────────────
@@ -125,6 +186,8 @@ class BotState:
         self.status            = "⏹ Остановлен"
         self.api_key           = ""
         self.api_secret        = ""
+        self.persist_api_keys_in_state = False  # Явное согласие пользователя хранить ключи в файле состояния
+                                                  # (нужно для авто-возобновления Live без Секретов HF - см. предупреждение в UI)
         self.target_profit     = 0.05       # Целевой профит на сделку (USDT)
         self.total_budget      = 25.0       # Общий выделенный бюджет
         self.num_slots         = DEFAULT_SLOTS
@@ -201,34 +264,70 @@ class BotState:
 
     def save_persisted_state(self):
         """
-        Сохраняет слоты и ключевую статистику на диск, чтобы пережить рестарт процесса
-        (сон/пробуждение HF Spaces, краш контейнера, ручной рестарт) без потери информации
-        о том, что куплено и по какой цене. Вызывается после каждой значимой мутации слота.
-        Ошибки записи на диск НЕ должны ронять торговый цикл - только логируются.
+        Сохраняет слоты, статистику И параметры торговли на диск + асинхронно в приватный
+        HF Dataset (если настроен), чтобы пережить ЛЮБОЙ рестарт контейнера, включая полный
+        редеплой (локальный диск это не переживает, датасет - переживает).
+        Флаг "is_running" в payload - основа для холодного автозапуска (maybe_cold_start_resume):
+        если он True при следующем старте процесса, бот сам поднимет trading_loop.
+        Ошибки записи НЕ должны ронять торговый цикл - только логируются.
         """
         try:
             payload = {
                 "saved_at": datetime.now(timezone.utc).isoformat(),
+                "is_running": self.is_running,
                 "paper_trading": self.paper_trading,
                 "num_slots": self.num_slots,
+                "total_budget": self.total_budget,
+                "target_profit": self.target_profit,
+                "use_bnb_discount": self.use_bnb_discount,
+                "use_timeout": self.use_timeout,
+                "order_timeout_min": self.order_timeout_min,
+                "use_profit_exit": self.use_profit_exit,
+                "profit_exit_timeout_min": self.profit_exit_timeout_min,
+                "strategy_mode": self.strategy_mode,
+                "use_dynamic_tp": self.use_dynamic_tp,
+                "max_correlation": self.max_correlation,
+                "use_depth_check": self.use_depth_check,
+                "max_slippage_pct": self.max_slippage_pct,
+                "strategy_engine": self.strategy_engine,
+                "grading_symbols": self.grading_symbols,
+                "grading_budget": self.grading_budget,
+                "auto_scale_slots": self.auto_scale_slots,
+                "proxy_url": self.proxy_url,
                 "total_profit": self.total_profit,
                 "trades_count": self.trades_count,
                 "slots": [s.to_dict() for s in self.slots],
             }
+            # API-ключи в файле - ТОЛЬКО если пользователь явно на это согласился в UI
+            # (по умолчанию выключено; безопаснее прописать BINANCE_API_KEY/SECRET в Секретах HF Spaces -
+            # они не попадают в этот файл и, соответственно, никогда не улетают в датасет)
+            if self.persist_api_keys_in_state and not self.paper_trading:
+                payload["api_key"] = self.api_key
+                payload["api_secret"] = self.api_secret
+
             tmp_path = STATE_FILE_PATH + ".tmp"
             with open(tmp_path, "w", encoding="utf-8") as f:
                 json.dump(payload, f, ensure_ascii=False)
             os.replace(tmp_path, STATE_FILE_PATH)  # атомарная замена - не оставит битый файл при обрыве записи
+
+            _push_state_to_hf_dataset(STATE_FILE_PATH)
         except Exception as e:
             logging.warning(f"Не удалось сохранить состояние на диск: {e}")
 
     @staticmethod
     def load_persisted_state() -> dict | None:
-        """Читает сохраненное состояние с диска, если файл существует. None, если файла нет или он битый."""
-        if not os.path.exists(STATE_FILE_PATH):
+        """
+        Читает сохраненное состояние. Приоритет: сначала пробуем скачать актуальную версию
+        из приватного HF Dataset (переживает полный редеплой), при неудаче/отсутствии -
+        читаем локальный файл на диске, если он еще жив. None - если нигде ничего нет
+        (это нормально для самого первого запуска, программа не должна падать).
+        """
+        hf_path = _pull_state_from_hf_dataset()
+        path_to_read = hf_path if hf_path else (STATE_FILE_PATH if os.path.exists(STATE_FILE_PATH) else None)
+        if not path_to_read:
             return None
         try:
-            with open(STATE_FILE_PATH, "r", encoding="utf-8") as f:
+            with open(path_to_read, "r", encoding="utf-8") as f:
                 return json.load(f)
         except Exception as e:
             logging.warning(f"Не удалось прочитать сохраненное состояние: {e}")
@@ -1278,6 +1377,9 @@ def process_occupied_slot(exchange: ccxt.binance, slot: Slot, state: BotState):
                 })
                 slot.clear()
                 state.save_persisted_state()
+            else:
+                slot.last_known_price = current_bid
+                elapsed_min = 0
                 if slot.order_placed_at:
                     elapsed_min = int((datetime.now(timezone.utc) - slot.order_placed_at).total_seconds() / 60)
                             
@@ -1315,7 +1417,14 @@ def process_occupied_slot(exchange: ccxt.binance, slot: Slot, state: BotState):
             elapsed_min = 0
             if slot.order_placed_at:
                 elapsed_min = int((datetime.now(timezone.utc) - slot.order_placed_at).total_seconds() / 60)
-                            
+
+            # Легкий доп. запрос цены для отображения незафиксированного P&L в UI (не критично при сбое)
+            try:
+                t = safe_call(exchange.fetch_ticker, slot.symbol, state=state, label=f"unrealized price {slot.symbol}")
+                slot.last_known_price = t.get("bid") or t.get("last") or slot.last_known_price
+            except Exception:
+                pass
+
             timeout_parts = []
             if state.use_timeout:
                 timeout_parts.append(f"timeout {state.order_timeout_min}м")
@@ -1540,6 +1649,93 @@ def trading_loop(state: BotState):
     state.status = "⏹ Остановлен"
 
 
+# Модульный флаг (НЕ st.session_state - тот привязан к браузерной сессии, а нам нужен
+# ровно один автозапуск на весь ЖИЗНЕННЫЙ ЦИКЛ ПРОЦЕССА, независимо от того, сколько
+# раз Streamlit перерисовывает скрипт или сколько вкладок браузера открыто).
+_cold_start_lock = threading.Lock()
+_cold_start_attempted = False
+
+
+def maybe_cold_start_resume(state: BotState):
+    """
+    Холодный старт: если сервер (контейнер HF Spaces) только что перезапустился/проснулся,
+    а в сохраненном состоянии стоит is_running=True - автоматически поднимает фоновый
+    trading_loop БЕЗ клика пользователя по кнопке "Запустить портфель".
+    Срабатывает ровно один раз за жизнь процесса благодаря module-level флагу.
+    """
+    global _cold_start_attempted
+    with _cold_start_lock:
+        if _cold_start_attempted:
+            return
+        _cold_start_attempted = True
+
+    if state.is_running:
+        return  # поток уже поднят в этом процессе - холодный старт не нужен
+
+    saved = BotState.load_persisted_state()
+    if not saved or not saved.get("is_running"):
+        return
+
+    state.log("♻️ Холодный старт: обнаружен флаг is_running=True в сохраненном состоянии - автозапуск торговли...", "INFO")
+
+    # ── Восстанавливаем параметры торговли из сохраненного состояния ──
+    state.paper_trading = saved.get("paper_trading", state.paper_trading)
+    state.total_budget = saved.get("total_budget", state.total_budget)
+    state.target_profit = saved.get("target_profit", state.target_profit)
+    state.use_bnb_discount = saved.get("use_bnb_discount", state.use_bnb_discount)
+    state.use_timeout = saved.get("use_timeout", state.use_timeout)
+    state.order_timeout_min = saved.get("order_timeout_min", state.order_timeout_min)
+    state.use_profit_exit = saved.get("use_profit_exit", state.use_profit_exit)
+    state.profit_exit_timeout_min = saved.get("profit_exit_timeout_min", state.profit_exit_timeout_min)
+    state.strategy_mode = saved.get("strategy_mode", state.strategy_mode)
+    state.use_dynamic_tp = saved.get("use_dynamic_tp", state.use_dynamic_tp)
+    state.max_correlation = saved.get("max_correlation", state.max_correlation)
+    state.use_depth_check = saved.get("use_depth_check", state.use_depth_check)
+    state.max_slippage_pct = saved.get("max_slippage_pct", state.max_slippage_pct)
+    state.strategy_engine = saved.get("strategy_engine", state.strategy_engine)
+    state.grading_symbols = saved.get("grading_symbols", state.grading_symbols)
+    state.grading_budget = saved.get("grading_budget", state.grading_budget)
+    state.auto_scale_slots = saved.get("auto_scale_slots", state.auto_scale_slots)
+    state.proxy_url = saved.get("proxy_url", state.proxy_url)
+    state.resize_slots(saved.get("num_slots", state.num_slots))
+
+    # ── API-ключи: ПРИОРИТЕТ у Секретов HF Spaces (переменные окружения) - они безопаснее,
+    # чем ключи, лежащие в файле состояния/датасете. Файл - только запасной вариант,
+    # и то ТОЛЬКО если пользователь сам явно включил "persist_api_keys_in_state" в UI. ──
+    env_key = os.environ.get("BINANCE_API_KEY", "")
+    env_secret = os.environ.get("BINANCE_API_SECRET", "")
+    if env_key and env_secret:
+        state.api_key = env_key
+        state.api_secret = env_secret
+        state.log("🔑 Холодный старт: API-ключи взяты из Секретов HF Spaces (приоритетный источник)", "OK")
+    elif not state.paper_trading:
+        saved_key = saved.get("api_key", "")
+        saved_secret = saved.get("api_secret", "")
+        if saved_key and saved_secret:
+            state.api_key = saved_key
+            state.api_secret = saved_secret
+            state.log(
+                "🔑 Холодный старт: Секреты HF Spaces не найдены, взял API-ключи из файла состояния "
+                "(менее безопасно - рекомендуется прописать BINANCE_API_KEY/BINANCE_API_SECRET в Секретах Space)",
+                "WARN",
+            )
+        else:
+            state.log(
+                "🔴 Холодный старт: нет API-ключей ни в Секретах HF, ни в сохраненном состоянии - "
+                "автозапуск Live невозможен, требуется ручной ввод ключей в UI", "ERR"
+            )
+            return
+
+    if not state.paper_trading and (not state.api_key or not state.api_secret):
+        return
+
+    state.is_running = True
+    state.status = "🔍 Автозапуск после рестарта..."
+    t = threading.Thread(target=trading_loop, args=(state,), daemon=True)
+    t.start()
+    state.log(f"♻️ Холодный старт: фоновый поток trading_loop запущен автоматически ({state.num_slots} слотов)", "OK")
+
+
 # ─────────────────────────────────────────────
 #  STREAMLIT ИНТЕРФЕЙС
 # ─────────────────────────────────────────────
@@ -1555,7 +1751,7 @@ def render_ui():
       .main { background-color: #0d1117; }
       .metric-card {
         background: #161b22; border: 1px solid #30363d; border-radius: 8px;
-        padding: 16px; text-align: center;
+        padding: 16px; text-align: center; color: #e6edf3;
       }
       .status-bar {
         background: #161b22; border-left: 3px solid #f0b429; padding: 10px 16px;
@@ -1567,13 +1763,14 @@ def render_ui():
       }
       .slot-card {
         background: #161b22; border: 1px solid #30363d; border-radius: 8px;
-        padding: 14px; margin-bottom: 10px;
+        padding: 14px; margin-bottom: 10px; color: #e6edf3;
       }
+      .slot-card b { color: #ffffff; }
       .slot-card.occupied { border-left: 3px solid #1f9d55; }
       .slot-card.empty { border-left: 3px solid #555; opacity: 0.7; }
       .panic-section {
         background: #2d1b1b; border: 1px solid #7c2d2d; border-radius: 8px;
-        padding: 10px 14px; margin-top: 8px;
+        padding: 10px 14px; margin-top: 8px; color: #e6edf3;
       }
       .screen-row {
         display: grid; grid-template-columns: 110px 90px 70px 70px 1fr;
@@ -1583,6 +1780,7 @@ def render_ui():
     """, unsafe_allow_html=True)
 
     state = get_bot_state()
+    maybe_cold_start_resume(state)  # автозапуск trading_loop после рестарта контейнера, если is_running был True
 
     st.markdown("## ⚡ GVP Micro Scalper — Ротационный портфель")
     st.caption("Полный скрин рынка | N параллельных позиций | Ротация при фиксации прибыли | HF Spaces")
@@ -1639,6 +1837,7 @@ def render_ui():
                 api_key = ""
                 api_secret = ""
                 proxy_url = state.proxy_url
+                persist_api_keys_in_state = False
             else:
                 api_key = st.text_input("API Key", value=state.api_key, type="password", key="inp_key")
                 api_secret = st.text_input("API Secret", value=state.api_secret, type="password", key="inp_secret")
@@ -1658,6 +1857,19 @@ def render_ui():
                 if proxy_url:
                     st.caption("🌐 Прокси будет применен ко всем запросам к бирже в Live режиме.")
 
+                st.divider()
+                persist_api_keys_in_state = st.checkbox(
+                    "Сохранять API-ключи в файле состояния/HF Dataset для автозапуска после рестарта",
+                    value=state.persist_api_keys_in_state,
+                    help=(
+                        "Нужно ТОЛЬКО если ты не прописал BINANCE_API_KEY/BINANCE_API_SECRET в Секретах "
+                        "HF Space (это приоритетный и более безопасный способ - ключи тогда вообще не "
+                        "попадают в этот файл). Если включишь здесь - ключи в открытом виде уйдут в JSON "
+                        "на диске и, если настроен HF Dataset, в твой приватный датасет. Используй, только "
+                        "если понимаешь риск: любой, у кого есть доступ к датасету/токену, увидит ключи."
+                    ),
+                )
+
         st.markdown("**Параметры торговли**")
         total_budget = st.number_input(
             "Общий бюджет портфеля (USDT)",
@@ -1823,6 +2035,7 @@ def render_ui():
                     state.grading_symbols = grading_symbols
                     state.grading_budget = grading_budget
                     state.auto_scale_slots = auto_scale_slots
+                    state.persist_api_keys_in_state = persist_api_keys_in_state
                     state.resize_slots(num_slots)
                     state.is_running = True
                     state.logs = []
@@ -1831,11 +2044,13 @@ def render_ui():
                     state.status = "🔍 Инициализация..."
                     t = threading.Thread(target=trading_loop, args=(state,), daemon=True)
                     t.start()
+                    state.save_persisted_state()  # сразу фиксируем is_running=True - основа холодного автозапуска
                     st.success(f"Портфель из {num_slots} слотов запущен!")
                     st.rerun()
         else:
             if st.button("⏹ Остановить портфель", use_container_width=True, type="secondary"):
                 state.is_running = False
+                state.save_persisted_state()  # фиксируем is_running=False - холодный автозапуск не сработает зря
                 st.warning("Сигнал остановки отправлен. Открытые позиции НЕ закрываются автоматически — используй Panic для каждого слота при необходимости.")
                 st.rerun()
 
@@ -1887,12 +2102,26 @@ def render_ui():
                 if state.use_profit_exit:
                     timeout_parts.append(f"плюс-ротация > {state.profit_exit_timeout_min}м")
                 timeout_str = " (" + " | ".join(timeout_parts) + ")" if timeout_parts else " (безлимит)"
+
+                # Незафиксированный P&L по последней увиденной цене - для ручного р��шения "закрыть/держать"
+                if slot.last_known_price > 0:
+                    unrealized_usd = slot.last_known_price * slot.bought_qty - slot.usdt_spent
+                    unrealized_cents = unrealized_usd * 100
+                    pnl_color = "#3fb950" if unrealized_usd >= 0 else "#f85149"
+                    pnl_sign = "+" if unrealized_usd >= 0 else ""
+                    pnl_html = (
+                        f'<span style="color:{pnl_color}; font-weight:600;">'
+                        f'{pnl_sign}{unrealized_usd:.4f} USDT ({pnl_sign}{unrealized_cents:.1f}¢)</span>'
+                    )
+                else:
+                    pnl_html = '<span style="color:#8b949e;">— (цена еще не проверялась)</span>'
                 
                 st.markdown(f"""
                 <div class="{css_class}">
                   <b>Слот {slot.index}: {slot.symbol}</b><br>
                   Куплено: {slot.bought_qty:.4f} по {slot.buy_price_avg:.6g} ({slot.usdt_spent:.4f} USDT)<br>
                   Цель продажи: <b>{slot.sell_price_set:.6g}</b> (цель profit: {slot.target_profit_set:.4f} USDT)<br>
+                  Незафиксированный P&L: {pnl_html}<br>
                   Статус: {slot.status} | Удержание: {elapsed_min} мин{timeout_str}
                 </div>
                 """, unsafe_allow_html=True)
@@ -1919,6 +2148,36 @@ def render_ui():
                         except Exception as e:
                             st.error(f"Ошибка Panic Sell: {e}")
 
+        # ── Сводная таблица открытых позиций: кто в плюсе, кто в просадке, сколько по времени ──
+        occupied_slots = [s for s in state.slots if not s.is_empty()]
+        if occupied_slots:
+            st.divider()
+            st.subheader("📊 Открытые позиции — незафиксированный P&L")
+            rows = []
+            for s in occupied_slots:
+                elapsed_min = 0
+                if s.order_placed_at:
+                    elapsed_min = int((datetime.now(timezone.utc) - s.order_placed_at).total_seconds() / 60)
+                if s.last_known_price > 0:
+                    u_usd = s.last_known_price * s.bought_qty - s.usdt_spent
+                    u_cents = u_usd * 100
+                    pnl_str = f"{'+' if u_usd >= 0 else ''}{u_usd:.4f} USDT"
+                    cents_str = f"{'+' if u_cents >= 0 else ''}{u_cents:.1f}¢"
+                    emoji = "🟢" if u_usd >= 0 else "🔴"
+                else:
+                    pnl_str, cents_str, emoji = "—", "—", "⏳"
+                rows.append({
+                    "": emoji,
+                    "Слот": s.index,
+                    "Монета": s.symbol,
+                    "Цена покупки": round(s.buy_price_avg, 6),
+                    "Тек. цена": round(s.last_known_price, 6) if s.last_known_price > 0 else "—",
+                    "P&L (USDT)": pnl_str,
+                    "P&L (центы)": cents_str,
+                    "В сделке (мин)": elapsed_min,
+                })
+            st.dataframe(pd.DataFrame(rows), use_container_width=True, hide_index=True)
+
         # ── Таблица виртуальных сделок ──
         st.divider()
         st.subheader("📝 Журнал сделок (Paper Trading)")