Update app.py

app.py

@@ -13,7 +13,7 @@ import pandas as pd
 # ─────────────────────────────────────────────
 #  КОНСТАНТЫ СТРАТЕГИИ
 # ─────────────────────────────────────────────
-SCREENER_INTERVAL_SEC   = 300        # Интервал полного сканирования рынка (5 минут)
+SCREENER_INTERVAL_SEC   = 90         # Интервал полного сканирования рынка (90 секунд для более частых входов)
 SLOT_REFILL_DEBOUNCE_SEC = 8         # Пауза перед заполнением освободившегося слота
 MIN_NOTIONAL_FILTER     = 1.0        # Фильтр минимального объема ордера (USDT)
 MIN_QUOTE_VOLUME        = 25_000     # Минимальный суточный объем торгов (USDT) (ослабили фильтр для расширения списка монет)
@@ -24,8 +24,8 @@ MIN_DRAWDOWN            = 0.01       # Минимальная просадка
 ORDER_TIMEOUT_MIN       = 30         # Время удержания позиции до авто-выхода (минут)
 FEE_RATE_STANDARD       = 0.001      # Стандартная комиссия (0.1%)
 FEE_RATE_BNB_DISCOUNT   = 0.00075    # Сниженная комиссия со скидкой BNB (0.075%)
-DEFAULT_SLOTS           = 3          # Количество параллельных слотов по умолчанию
-MAX_SLOTS               = 6          # Защита от избыточного дробления бюджета
+DEFAULT_SLOTS           = 5          # Количество параллельных слотов по умолчанию
+MAX_SLOTS               = 12         # Защита от избыточного дробления бюджета (увеличено для поддержки 5+ слотов)
 CANDLE_FETCH_BATCH_SIZE = 25         # Увеличили батч скрининга до 25 для анализа большего количества монет
 
 
@@ -86,6 +86,8 @@ class BotState:
         self.allowed_symbols_count = 0      # Кол-во доступных USDT пар
         self.order_timeout_min  = 360       # Время удержания до авто-выхода в минутах (6 часов по умолчанию)
         self.use_timeout        = False     # Принудительный выход по тайм-ауту по умолчанию выключен по вашей просьбе
+        self.use_profit_exit    = True       # Включить ротацию по плюсу после определенного времени удержания
+        self.profit_exit_timeout_min = 120   # Тайм-аут удержания до проверки профита в минутах (2 часа)
         self.strategy_mode      = "⚖️ Умеренный (Сбалансированный)" # Режим скальпинга
         self.use_dynamic_tp     = True      # Использовать адаптивный Тейк-Профит на основе волатильности
 
@@ -499,8 +501,13 @@ def place_limit_sell(exchange: ccxt.binance, slot: Slot, state: BotState) -> boo
     try:
         symbol = slot.symbol
         fee = state.fee_rate()
-        usdt_out = slot.usdt_spent + slot.target_profit_set
-        sell_raw = usdt_out / (slot.bought_qty * (1 - fee))
+        if state.use_bnb_discount:
+            # С учетом скидки BNB, монеты при покупке НЕ урезались (qty полный)
+            sell_raw = (slot.usdt_spent + slot.target_profit_set) / slot.bought_qty
+        else:
+            # Без скидки (стандартный расчет)
+            usdt_out = slot.usdt_spent + slot.target_profit_set
+            sell_raw = usdt_out / (slot.bought_qty * (1 - fee))
         sell_px = float(exchange.price_to_precision(symbol, sell_raw))
         qty = float(exchange.amount_to_precision(symbol, slot.bought_qty))
 
@@ -535,10 +542,9 @@ def place_limit_sell(exchange: ccxt.binance, slot: Slot, state: BotState) -> boo
         state.log(f"[Слот {slot.index}] LimitSell ОШИБКА: {e}", "ERR")
         return False
 
-def panic_sell_slot(exchange: ccxt.binance, slot: Slot, state: BotState, manual: bool = False):
-    prefix = "🚨 PANIC" if manual else "⏰ TIMEOUT"
+def panic_sell_slot(exchange: ccxt.binance, slot: Slot, state: BotState, prefix: str = "🚨 PANIC"):
     sym = slot.symbol
-    state.log(f"{prefix} [Слот {slot.index}]: экстренный выход из {sym}", "WARN")
+    state.log(f"{prefix} [Слот {slot.index}]: принудительный/таймаут выход из {sym}", "WARN")
 
     if state.paper_trading:
         try:
@@ -546,13 +552,25 @@ def panic_sell_slot(exchange: ccxt.binance, slot: Slot, state: BotState, manual:
             current_bid = ticker.get("bid") or ticker.get("last") or slot.buy_price_avg
             received = slot.bought_qty * current_bid
             loss = received - slot.usdt_spent
+            
+            # Обновляем общую статистику сессии (прибыль/убыток) при любом выходе
+            state.total_profit += loss
+            state.trades_count += 1
+            
             state.log(
                 f"📝 {prefix} [Слот {slot.index}]: виртуальная продажа {slot.bought_qty:.6g} "
                 f"{sym.split('/')[0]} по РЕАЛЬНОЙ цене {current_bid:.6g}, получено approx {received:.4f} USDT. "
                 f"изменение approx {loss:.4f} USDT", "WARN"
             )
+            
+            action_type = "panic"
+            if "TIMEOUT" in prefix:
+                action_type = "timeout"
+            elif "ROTATE" in prefix:
+                action_type = "rotation"
+                
             state.record_paper_trade({
-                "symbol": sym, "action": "panic", "slot": slot.index,
+                "symbol": sym, "action": action_type, "slot": slot.index,
                 "price": current_bid, "qty": slot.bought_qty,
                 "usdt_value": received, "profit": loss,
             })
@@ -566,7 +584,7 @@ def panic_sell_slot(exchange: ccxt.binance, slot: Slot, state: BotState, manual:
             exchange.cancel_order(slot.order_id, sym)
             state.log(f"{prefix} [Слот {slot.index}]: лимит ID={slot.order_id} отменен", "OK")
         except Exception as e:
-            state.log(f"{prefix} [Слот {slot.index}]: ошибка отмены ордера: {e}", "WARN")
+            state.log(f"{prefix} [Слот {slot.index}]: ошибка отмены лимитного ордера: {e}", "WARN")
 
     time.sleep(1)
 
@@ -584,6 +602,11 @@ def panic_sell_slot(exchange: ccxt.binance, slot: Slot, state: BotState, manual:
         order = exchange.create_market_sell_order(sym, qty_sell)
         received = float(order.get("cost") or 0)
         loss = received - slot.usdt_spent
+        
+        # Обновляем общую статистику сессии
+        state.total_profit += loss
+        state.trades_count += 1
+        
         state.log(
             f"{prefix} [Слот {slot.index}]: продано {qty_sell} {base}, получено approx {received:.4f} USDT. "
             f"изменение approx {loss:.4f} USDT", "WARN"
@@ -595,28 +618,42 @@ def panic_sell_slot(exchange: ccxt.binance, slot: Slot, state: BotState, manual:
     slot.clear()
 
 
-def refill_slot(exchange: ccxt.binance, allowed_symbols: list[str], slot: Slot, state: BotState):
+def refill_empty_slots(exchange: ccxt.binance, allowed_symbols: list[str], empty_slots: list[Slot], state: BotState):
+    """Выполняет один общий пакетный скриншот рынка для всех пустых слотов сразу."""
     now = time.time()
-    if now - slot.last_refill_attempt < SLOT_REFILL_DEBOUNCE_SEC:
+    
+    # Фильтруем слоты, готовые к наполнению
+    slots_to_refill = [s for s in empty_slots if now - s.last_refill_attempt >= SLOT_REFILL_DEBOUNCE_SEC]
+    if not slots_to_refill:
         return
-    slot.last_refill_attempt = now
-    slot.status = "🔍 Поиск замены"
+
+    for slot in slots_to_refill:
+        slot.last_refill_attempt = now
+        slot.status = "🔍 Поиск замены"
 
     occupied = state.occupied_symbols()
-    candidates = screen_full_market(exchange, allowed_symbols, occupied, state, need_n=1)
+    need_n = len(slots_to_refill)
+
+    # Делаем один общий скрин рынка и забираем до need_n лучших уникальных кандидатов
+    candidates = screen_full_market(exchange, allowed_symbols, occupied, state, need_n=need_n)
 
     if not candidates:
-        state.log(f"[Слот {slot.index}] Нет подходящих кандидатов в этом цикле", "INFO")
+        for slot in slots_to_refill:
+            slot.status = "🔍 Поиск"
+        state.log(f"Нет подходящих кандидатов в этом цикле для {need_n} пустых слотов", "INFO")
         return
 
-    best = candidates[0]
-    slot.status = f"🟡 Покупка {best['symbol']}"
-    ok_buy = execute_buy(exchange, best["symbol"], state.budget_per_slot(), slot, state)
-    if ok_buy:
-        ok_sell = place_limit_sell(exchange, slot, state)
-        if not ok_sell:
-            state.log(f"[Слот {slot.index}] LimitSell не удался -> экстренная продажа слота", "ERR")
-            panic_sell_slot(exchange, slot, state)
+    # Заполняем слоты найденными кандидатами
+    for slot, best in zip(slots_to_refill, candidates):
+        slot.status = f"🟡 Покупка {best['symbol']}"
+        ok_buy = execute_buy(exchange, best["symbol"], state.budget_per_slot(), slot, state)
+        if ok_buy:
+            ok_sell = place_limit_sell(exchange, slot, state)
+            if not ok_sell:
+                state.log(f"[Слот {slot.index}] LimitSell не удался -> экстренная продажа слота", "ERR")
+                panic_sell_slot(exchange, slot, state, prefix="🚨 PANIC")
+        else:
+            slot.clear()
 
 
 # ─────────────────────────────────────────────
@@ -672,10 +709,39 @@ def trading_loop(state: BotState):
 
                 if slot.order_placed_at:
                     elapsed = (datetime.now(timezone.utc) - slot.order_placed_at).total_seconds()
+                    
+                    # 1. Жесткий тайм-аут выхода по рынку (если включен)
                     if state.use_timeout and elapsed > state.order_timeout_min * 60:
-                        state.log(f"[Слот {slot.index}] Тайм-аут {state.order_timeout_min} мин — авто-выход", "WARN")
-                        panic_sell_slot(exchange, slot, state)
+                        state.log(f"[Слот {slot.index}] Жесткий тайм-аут {state.order_timeout_min} мин — авто-выход", "WARN")
+                        panic_sell_slot(exchange, slot, state, prefix="⏰ TIMEOUT")
                         continue
+                    
+                    # 2. Ротация по плюсовой прибыли с учетом комиссий по истечении заданного времени (например, 2 часа)
+                    if state.use_profit_exit and elapsed > state.profit_exit_timeout_min * 60:
+                        try:
+                            ticker = exchange.fetch_ticker(slot.symbol)
+                            current_bid = ticker.get("bid") or ticker.get("last") or 0
+                            
+                            if current_bid > 0:
+                                fee = state.fee_rate()
+                                # Расчет чистой прибыли при рыночной продаже по цене current_bid
+                                if state.use_bnb_discount:
+                                    # Оплата в BNB (0.075% на входе и выходе)
+                                    net_profit = (slot.bought_qty * current_bid) - slot.usdt_spent - (slot.usdt_spent * fee) - (slot.bought_qty * current_bid * fee)
+                                else:
+                                    # Стандартная комиссия урезает количество на входе, а на выходе берется из USDT
+                                    net_profit = (slot.bought_qty * current_bid * (1 - fee)) - slot.usdt_spent
+                                
+                                if net_profit > 0.0:
+                                    state.log(
+                                        f"[Слот {slot.index}] Ротация: удержание {slot.symbol} превысило {state.profit_exit_timeout_min} мин. "
+                                        f"Рыночная цена {current_bid:.6g} дает чистый профит +{net_profit:.4f} USDT с учетом комиссий. "
+                                        f"Закрываем позицию для высвобождения слота!", "OK"
+                                    )
+                                    panic_sell_slot(exchange, slot, state, prefix="⏰ ROTATE")
+                                    continue
+                        except Exception as e:
+                            state.log(f"[Слот {slot.index}] Ошибка при расчете плюсовой ротации: {e}", "WARN")
 
                 try:
                     if state.paper_trading:
@@ -735,6 +801,7 @@ def trading_loop(state: BotState):
                 except Exception as e:
                     state.log(f"[Слот {slot.index}] Ошибка проверки ордера: {e}", "WARN")
 
+            # Пакетное наполнение пустых слотов за один общий проход скринера
             empty_slots = [s for s in state.slots if s.is_empty()]
 
             if empty_slots:
@@ -744,10 +811,7 @@ def trading_loop(state: BotState):
                 )
                 if should_screen:
                     state.last_full_screen_at = now
-                    for slot in empty_slots:
-                        if not state.is_running:
-                            break
-                        refill_slot(exchange, allowed_symbols, slot, state)
+                    refill_empty_slots(exchange, allowed_symbols, empty_slots, state)
 
             occupied_n = sum(1 for s in state.slots if not s.is_empty())
             if occupied_n == state.num_slots:
@@ -904,16 +968,28 @@ def render_ui():
             help="Снижает комиссию с 0.1% до 0.075%. ВАЖНО: должно совпадать с реальной настройкой в Binance, иначе цена продажи будет рассчитана неточно и часть прибыли уходит в погрешность."
         )
         use_timeout = st.checkbox(
-            "Включить принудительный выход по тайм-ауту",
+            "Включить принудительный выход по жесткому тайм-ауту",
             value=state.use_timeout,
-            help="Если выключено, бот будет держать купленную монету бесконечно, пока она не продастся в гарантированный плюс. Если включено, закроет в минус/плюс по рынку через указанное время."
+            help="Если выключено, бот будет держать купленную монету, пока она не продастся по лимиту или плюсовой ротации."
         )
         order_timeout_min = st.number_input(
-            "Тайм-аут удержания позиции (минут)",
+            "Тайм-аут жесткого удержания позиции (минут)",
             min_value=10, max_value=14400, value=state.order_timeout_min, step=10,
             disabled=not use_timeout,
-            help="Применяется только при включенном флаге выше."
+            help="Применяется только при включенном жестком фланге выше."
         )
+        use_profit_exit = st.checkbox(
+            "Включить ротацию по профиту через время",
+            value=state.use_profit_exit,
+            help="Если включено, по истечении тайм-аута удержания бот закроет позицию по рынку, только если текущая чистая прибыль с учетом всех комиссий положительна (> 0 USDT)."
+        )
+        profit_exit_timeout_min = st.number_input(
+            "Тайм-аут до проверки плюсовой ротации (минут)",
+            min_value=10, max_value=14400, value=state.profit_exit_timeout_min, step=10,
+            disabled=not use_profit_exit,
+            help="Минимальное время удержания позиции (например, 120 минут = 2 часа) перед началом регулярных проверок на выход в плюс."
+        )
+
         active_fee = FEE_RATE_BNB_DISCOUNT if use_bnb else FEE_RATE_STANDARD
 
         per_slot_preview = total_budget / num_slots if num_slots else 0
@@ -941,6 +1017,8 @@ def render_ui():
                     state.use_bnb_discount = use_bnb
                     state.use_timeout = use_timeout
                     state.order_timeout_min = order_timeout_min
+                    state.use_profit_exit = use_profit_exit
+                    state.profit_exit_timeout_min = profit_exit_timeout_min
                     state.strategy_mode = strategy_mode
                     state.use_dynamic_tp = use_dynamic_tp
                     state.resize_slots(num_slots)
@@ -962,8 +1040,9 @@ def render_ui():
         st.divider()
         st.markdown("**📐 Формула цены продажи (на слот)**")
         st.code(
-            "sell_price = (usdt_spent + target_profit)\n"
-            "           / (bought_qty * (1 - fee_rate))\n\n"
+            "sell_price = (usdt_spent + target_profit) / bought_qty [При оплате в BNB]\n"
+            "или\n"
+            "sell_price = (usdt_spent + target_profit) / (bought_qty * (1 - fee_rate)) [Стандарт]\n\n"
             f"budget_per_slot = total_budget / num_slots\n"
             f"fee_rate = {active_fee} ({fee_label})",
             language="python"
@@ -1002,13 +1081,19 @@ def render_ui():
                 elapsed_min = 0
                 if slot.order_placed_at:
                     elapsed_min = int((datetime.now(timezone.utc) - slot.order_placed_at).total_seconds() / 60)
-                timeout_str = f"/{state.order_timeout_min} мин" if state.use_timeout else " (безлимит)"
+                timeout_parts = []
+                if state.use_timeout:
+                    timeout_parts.append(f"timeout {state.order_timeout_min}м")
+                if state.use_profit_exit:
+                    timeout_parts.append(f"плюс-ротация > {state.profit_exit_timeout_min}м")
+                timeout_str = " (" + " | ".join(timeout_parts) + ")" if timeout_parts else " (безлимит)"
+                
                 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>
-                  Статус: {slot.status} | {elapsed_min}{timeout_str}
+                  Статус: {slot.status} | Удержание: {elapsed_min} мин{timeout_str}
                 </div>
                 """, unsafe_allow_html=True)
 
@@ -1019,7 +1104,7 @@ def render_ui():
                                 exchange = build_exchange("", "", paper_trading=True)
                             else:
                                 exchange = build_exchange(state.api_key, state.api_secret, paper_trading=False)
-                            panic_sell_slot(exchange, slot, state, manual=True)
+                            panic_sell_slot(exchange, slot, state, prefix="🚨 PANIC")
                             st.warning(f"Слот {slot.index} closed принудительно!")
                             st.rerun()
                         except Exception as e: