import time
import math
import threading
import logging
import uuid
import json
import os
from datetime import datetime, timezone
from dataclasses import dataclass, asdict
import ccxt
import streamlit as st
import pandas as pd
import plotly.graph_objects as go
# ─────────────────────────────────────────────
# КОНСТАНТЫ СТРАТЕГИИ
# ─────────────────────────────────────────────
SCREENER_INTERVAL_SEC = 90 # Интервал полного сканирования рынка (90 секунд для более частых входов)
SLOT_REFILL_DEBOUNCE_SEC = 8 # Пауза перед заполнением освободившегося слота
MIN_NOTIONAL_FILTER = 1.0 # Фильтр минимального объема ордера (USDT)
MIN_QUOTE_VOLUME = 200_000 # Минимальный суточный объем торгов (USDT). Было 25_000 (ослабляли специально
# для расширения списка монет). Подняли 2026-07-25 - слишком широкий хвост
# микрокапов оказался частью синхронной просадки сразу нескольких слотов
# при общем откате рынка. 200k - компромисс: отсекает токсичный хвост, но
# не откатывает расширение пула целиком, в отличие от жесткого топ-30/50
# (который резко просадил бы частоту сделок и противоречил бы поведенческой
# мем-тир логике ниже - см. HIGH_VOLATILITY_MEME_THRESHOLD).
MAX_SPREAD_RATIO = 0.003 # Максимальный спред для входа (0.3%)
CANDLE_LIMIT = 30 # 30 свечей по 1м для расчета RSI-1m и поиска дивергенций
MIN_VOLATILITY = 0.008 # Минимальная волатильность за час (0.8%)
MIN_DRAWDOWN = 0.01 # Минимальная просадка от часового пика (1%)
ORDER_TIMEOUT_MIN = 30 # Время удержания позиции до авто-выхода (минут)
FEE_RATE_STANDARD = 0.001 # Стандартная комиссия (0.1%)
FEE_RATE_BNB_DISCOUNT = 0.00075 # Сниженная комиссия со скидкой BNB (0.075%)
DEFAULT_SLOTS = 5 # Количество параллельных слотов по умолчанию
MAX_SLOTS = 12 # Защита от избыточного дробления бюджета (увеличено для поддержки 5+ слотов)
CANDLE_FETCH_BATCH_SIZE = 90 # Подняли с 55 до 90 (запрос от 2026-07-15): при среднем ~384
# кандидатах, проходящих объем/спред, батч=55 давал индикаторный
# анализ лишь ~14% из них - это была основная причина редких сделок,
# а НЕ MIN_QUOTE_VOLUME/MAX_SPREAD_RATIO (те отсеивают лишь ~15% от
# всех разрешенных пар). Подняли умеренно, а не сразу до "всех": это
# почти удвоит число запросов свечей за скрин, а авто-бэкофф ниже
# существует именно потому, что даже 55 уже ощутимо давит на рейт-
# лимиты Binance (см. комментарий у SCREENER_ERROR_WINDOW_SEC).
MAX_CORRELATION_DEFAULT = 0.75 # Порог макс. корреляции доходностей между отбираемыми монетами (диверсификация слотов)
CORRELATION_LOOKBACK = 30 # Кол-во 1м свечей для расчета корреляции доходностей
EXCHANGE_RETRY_ATTEMPTS = 3 # Кол-во повторных попыток при сетевых сбоях биржи
EXCHANGE_RETRY_DELAY_SEC = 1.5 # Базовая задержка между повторными попытками (экспоненциально растет)
RSI_BOTTOM_LOOKBACK = 5 # Окно свечей для поиска локального дна RSI
RSI_BOTTOM_CONFIRM_BARS = 2 # Кол-во ПОДРЯД неубывающих шагов RSI для подтверждения разворота.
# Было 1 (current >= prev) - этого достаточно, чтобы RSI дернулся
# вверх на одну шумную 1m свечу и тут же снова пошел вниз (ложный
# разворот). 2 подряд неубывающих шага - более надежное подтверждение.
# ── Фильтр старшего тренда (защита от "падающих ножей") ──
# Разворотные сигналы в screen_full_market (дивергенция/RSI-дно/Боллинджер) считаются на
# 1h/15m/1m - это "видит" только краткосрочный микро-отскок и ничего не знает про то,
# находится ли монета уже несколько дней в устойчивом падении. Здесь мы дополнительно
# смотрим на 4h SMA: если она снижается И цена уже далеко ниже нее - это не "дип для покупки",
# а падающий нож в структурном даунтренде, и вход пропускается, даже если 1m/15m сигнал сработал.
HTF_TREND_TIMEFRAME = "4h" # Старший таймфрейм для фильтра общего тренда
HTF_TREND_CANDLE_LIMIT = 50 # Свечей 4h для анализа (50 x 4ч ≈ 8.3 дня истории)
HTF_TREND_SMA_PERIOD = 20 # Период SMA на старшем ТФ (20 x 4ч ≈ 3.3 дня)
HTF_TREND_SMA_SLOPE_LOOKBACK = 5 # На сколько свечей назад сравниваем SMA для определения наклона (растет/падает)
HTF_TREND_MAX_BELOW_SMA_PCT = 5.5 # Макс. допустимое отклонение цены НИЖЕ SMA (%), если SMA при этом падает.
# Было 8.0, снижено 2026-07-25 после случая одновременной просадки
# нескольких слотов на общем откате рынка. Не опускать ниже ~5.0-5.5:
# MTF ниже специально мягче HTF (порог 4.0) - если HTF станет строже
# MTF, слоистая логика "HTF=общая картина, MTF=быстрая проверка" ломается.
HTF_TREND_CACHE_TTL_SEC = 1800 # Кэш результата на 30 минут - 4h свеча меняется медленно, незачем
# дергать 4h-эндпоинт на КАЖДОМ скрине (раз в ~90-270с) для той же монеты
# ── Среднесрочный (1h) трендовый фильтр - ловит "свежие" многочасовые даунтренды ──
# HTF-фильтр выше смотрит на 4h SMA(20) - это ~3.3 дня истории, и физически инертен: даунтренд,
# начавшийся всего несколько часов назад, еще не успевает заметно сдвинуть такую медленную SMA,
# поэтому HTF пропускает такие входы. Здесь используем ТОТ ЖЕ принцип (наклон SMA + отклонение
# цены от нее), но на более быстром 1h таймфрейме с более коротким периодом - это ДОПОЛНИТЕЛЬНЫЙ
# слой защиты поверх HTF, а не замена ему (многодневные структурные даунтренды по-прежнему ловит HTF).
MTF_TREND_FILTER_ENABLED = True
MTF_TREND_TIMEFRAME = "1h" # Среднесрочный таймфрейм для более быстрого фильтра тренда
MTF_TREND_CANDLE_LIMIT = 30 # Свечей 1h для анализа
MTF_TREND_SMA_PERIOD = 12 # Период SMA на среднем ТФ (12 x 1ч = 12 часов)
MTF_TREND_SMA_SLOPE_LOOKBACK = 3 # На сколько свечей назад сравниваем SMA для определения наклона
MTF_TREND_MAX_BELOW_SMA_PCT = 4.0 # Порог мягче, чем у HTF (8.0%) - здесь ловим более свежий/короткий тренд
MTF_TREND_CACHE_TTL_SEC = 600 # Короче, чем у HTF (30 мин) - 1h свеча "устаревает" для нас быстрее
# ── BTC Market Guard - защита от покупок алтов во время рыночного (BTC-led) провала ──
# Фильтр диверсификации (calculate_correlation/max_correlation) сравнивает кандидатов только ДРУГ
# С ДРУГОМ и с уже открытыми позициями по 30-минутному окну доходностей - BTC как отдельный
# системный фактор риска там не участвует. Если на момент входа рынок был спокоен, разные по
# сектору монеты вполне могли пройти фильтр (низкая взаимная корреляция), а затем синхронно
# просесть вместе с BTC при резком движении рынка (см. случай 2026-07-25: одновременная просадка
# 5 слотов из разных секторов - ZEC/ONDO/SUI/ALLO/JTO). Этот гейт - прямая дешевая проверка тренда
# самого BTC перед ЛЮБОЙ покупкой в движке Портфеля. НЕ распространяется на Градацию - там смысл
# стратегии как раз в докупке BTC/ETH на просадке, гейт "BTC падает -> не покупать" убил бы саму
# стратегию.
BTC_GUARD_ENABLED = True
BTC_GUARD_SYMBOL = "BTC/USDT"
BTC_GUARD_TIMEFRAME = "15m" # Быстрый таймфрейм - нужно поймать начавшийся провал, а не структурный тренд
BTC_GUARD_LOOKBACK = 2 # Сравниваем текущую цену с ценой N свечей назад (2 x 15m = 30 минут)
BTC_GUARD_MAX_DROP_PCT = 0.5 # Если BTC упал более чем на X% за это окно - покупки в Портфеле приостанавливаются
BTC_GUARD_CACHE_TTL_SEC = 60 # Кэш результата - проверяется один раз за скрин, а не на каждого кандидата
# ── Подтверждение объемом на входе ──
# Разворотные индикаторы (RSI-дно/дивергенция/Боллинджер) сами по себе не отличают "реальный
# отскок со спросом" от монеты, которая просто затихла перед следующим проливом. Требуем всплеск
# объема на подтверждающей 1m свече относительно недавнего среднего.
VOLUME_CONFIRMATION_ENABLED = True
VOLUME_CONFIRMATION_LOOKBACK = 20 # Свечей для расчета среднего объема
VOLUME_CONFIRMATION_MULTIPLIER = 1.3 # Объем последней свечи должен быть минимум в X раз больше среднего
# ── Подтверждение дивергенции RSI на 15m ──
# detect_bullish_divergence сама по себе - чисто геометрический паттерн (цена ниже/равна, RSI выше на
# второй впадине), и уже требует r2 < 45 внутри себя, но этого может быть недостаточно строгим сигналом
# самим по себе. Добавляем дополнительное требование СВЕРХУ: на момент сигнала RSI(15m) должен быть
# отчетливо в зоне перепроданности. Если не проходит - дивергенция как самостоятельный триггер входа
# не засчитывается (остальные сигналы - RSI-дно на 1m, Боллинджер - продолжают работать независимо).
RSI_15M_DIVERGENCE_CONFIRM_ENABLED = True
RSI_15M_DIVERGENCE_CONFIRM_MAX = 35.0
# ── Дисбаланс ликвидности в стакане на входе ──
# Технические индикаторы не видят реальный спрос прямо сейчас - только историю свечей. Стакан
# показывает это напрямую: если под ценой (bids) значительно больше ликвидности, чем над ней
# (asks), это похоже на реальную поддержку покупателей, а не на "техническое дно".
BOOK_IMBALANCE_ENABLED = True
BOOK_IMBALANCE_DEPTH_PCT = 1.0 # Анализируем стакан в пределах ±1% от текущей цены
BOOK_IMBALANCE_MIN_RATIO = 1.2 # bid-ликвидность должна быть минимум в 1.2 раза больше ask-ликвидности
# ── Фильтр скорости падения (защита от входа в еще активно падающую монету) ──
# Разворотные сигналы (RSI-дно/дивергенция/Боллинджер) могут сработать на ОДНОЙ 1m свече, даже
# если монета в моменте продолжает практически свободное падение - например, кратковременный
# технический отскок на фоне сильного нисходящего импульса. Дополнительно проверяем % изменения
# цены за последние FREEFALL_LOOKBACK_CANDLES 1m свечей (данные уже загружены для RSI/Боллинджера,
# доп. запрос к API не нужен): если падение за это окно все еще превышает FREEFALL_MAX_DROP_PCT -
# вход пропускается независимо от остальных сигналов, т.к. это похоже на активно продолжающийся
# обвал, а не на остановившуюся просадку.
FREEFALL_GUARD_ENABLED = True
FREEFALL_LOOKBACK_CANDLES = 5 # Смотрим на изменение цены за последние 5 1m свечей (~5 минут)
FREEFALL_MAX_DROP_PCT = 2.5 # Если упало более чем на 2.5% за это окно - считаем "еще падает", пропуск
# ── Верхняя граница просадки на входе (защита от "ловли обвала") ──
# adaptive_min_drawdown ниже задает только НИЖНЮЮ границу (просадка должна быть достаточной,
# чтобы вообще иметь смысл для скальпа) - верхней границы раньше не было вообще. Провал на
# 15-20%+ за 30-минутное окно (CANDLE_LIMIT=30 1m свечей) - это, скорее, начало настоящего
# обвала, а не "дип для скальпа": именно такие кандидаты статистически дольше всего потом
# сидят в минусе. Работает НЕЗАВИСИМО от freefall-фильтра выше: freefall смотрит на СКОРОСТЬ
# падения ПРЯМО СЕЙЧАС (последние 5 минут), а этот порог - на ОБЩУЮ глубину провала за все
# 30-минутное окно, даже если в последние минуты падение уже замедлилось.
MAX_DRAWDOWN_FROM_1M_HIGH_PCT = 6.5 # Просадка от 30-минутного хая свыше этого % - уже не "дип", пропуск.
# Было 10.0, снижено 2026-07-25 (тот же случай, что и у HTF выше).
# Не опускать ниже ~6: в Умеренном режиме (drawdown_mult=0.14) нижняя
# граница входа для монет с 24h-волатильностью ~25%+ и так уже
# приближается к этому значению (adaptive_min_drawdown = volatility_24h *
# drawdown_mult) - порог ниже 6% начинает схлопывать окно входа для
# части мем-тира до нуля.
# ── "Мем-тир" - ужесточение для аномально волатильных монет ──
# Кейс PUMP: RSI-дно + всплеск объема сработали на резкий, но ЛОЖНЫЙ импульс посреди бокового
# шума - типично для низкокапных/мемных монет, где объемные всплески чаще манипулятивные, чем
# признак реального разворота. Вместо хрупкого списка тикеров определяем "мем-тир" ПО ПОВЕДЕНИЮ
# (аномальная суточная волатильность) и для таких монет требуем заметно более сильное
# подтверждение объемом и стаканом, чем для обычных кандидатов.
HIGH_VOLATILITY_MEME_THRESHOLD = 0.15 # 24h волатильность (high-low)/low, выше которой считаем монету мем-тиром
MEME_TIER_VOLUME_MULTIPLIER = 2.0 # Для мем-тира: объем свечи должен быть минимум в 2x выше среднего (вместо 1.3x)
MEME_TIER_BOOK_MIN_RATIO = 1.8 # Для мем-тира: bid-ликвидность должна перевешивать ask сильнее (вместо 1.2x)
# ── Убывающий тейк-профит для зависших позиций ──
# use_timeout=False и профит-ротация (срабатывает только при net_profit > 0) означают, что
# позиция, ушедшая в минус и не отросшая обратно к изначальной цели, может висеть в слоте
# бесконечно. Это НЕ стоп-лосс (мы не продаем принудительно в минус) - просто со временем
# СНИЖАЕМ саму цель прибыли (target_profit_set), чтобы лимитка стала более реалистичной и
# позиции было легче закрыться хотя бы в небольшой плюс, а не ждать полного отката к
# изначальной, возможно слишком оптимистичной, цене. Никогда не опускаем цель ниже
# STALE_POSITION_MIN_PROFIT_FLOOR_PCT от суммы сделки.
STALE_POSITION_DECAY_START_MIN = 720 # Начинаем снижать цель, если слот висит без исполнения дольше 12 часов
STALE_POSITION_DECAY_INTERVAL_MIN = 240 # Очередной шаг снижения - не чаще, чем раз в 4 часа
STALE_POSITION_DECAY_STEP_PCT = 0.15 # На сколько % от ТЕКУЩЕЙ цели снижаем ее на каждом шаге
STALE_POSITION_MIN_PROFIT_FLOOR_PCT = 0.05 # Минимальный пол цели (% от usdt_spent) - ниже не опускаем
# ── Авто-бэкофф скринера при сетевых сбоях ──
# 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),
(50, 6),
(100, 7),
(200, 8),
(400, 9),
(700, 10),
(1000, 11),
(1500, 12),
]
AUTOSCALE_CHECK_INTERVAL_SEC = 3600 # Проверять реальный баланс раз в час (не смысла чаще - депозит не растет каждую минуту)
SYMBOLS_REFRESH_INTERVAL_SEC = 3600 # Раз в час пересчитывать список разрешенных пар под текущий бюджет/слот
# ── Персистентность состояния слотов на диск + публичный 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, state: "BotState"):
"""
Асинхронно заливает файл состояния в публичный HF Dataset через ОДИН сериализованный
воркер на BotState (не отдельный поток на каждый вызов!). save_persisted_state()
вызывается очень часто (после каждой сделки), и раньше каждый вызов спавнил свой
независимый поток аплоада - без гарантии порядка завершения по сети. При активной
торговле это давало РЕАЛЬНЫЙ баг: аплоад со СТАРым payload (например, is_running=True
из сделки за секунду до нажатия "Стоп") мог по сети завершиться ПОЗЖЕ, чем аплоад с
новым payload (is_running=False) - и облако откатывалось на устаревшее состояние,
из-за чего после ребилда бот "воскресал" даже после явной остановки.
Теперь: если воркер уже заливает - новый вызов просто помечает "есть более свежая
версия", и ТОТ ЖЕ воркер после завершения текущей попытки перечитывает local_path
(он к этому моменту уже содержит самые актуальные данные, т.к. локальная запись
синхронна) и заливает снова - пока не останется несливающихся изменений.
"""
if not _hf_dataset_configured():
return
with state._hf_upload_lock:
state._hf_upload_pending = True
if state._hf_upload_in_progress:
return # воркер уже работает - он сам подхватит актуальную версию файла
state._hf_upload_in_progress = True
def _upload_loop():
try:
from huggingface_hub import HfApi
api = HfApi(token=HF_TOKEN)
# exist_ok=True - безопасно дергать при КАЖДОЙ заливке, датасет создается
# автоматически только один раз, при первом реальном запуске.
# По просьбе пользователя private=False, чтобы не требовать приватного спейса/лимитов.
api.create_repo(repo_id=HF_DATASET_ID, repo_type="dataset", private=False, exist_ok=True)
while True:
with state._hf_upload_lock:
state._hf_upload_pending = False
try:
# path_or_fileobj=local_path - huggingface_hub читает файл С ДИСКА в
# момент вызова, поэтому если локальный файл уже успели перезаписать
# заново (более новым save_persisted_state), уйдет уже АКТУАЛЬНАЯ версия.
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}")
with state._hf_upload_lock:
if not state._hf_upload_pending:
state._hf_upload_in_progress = False
return
# пока шла заливка, пришла более новая версия - повторяем цикл заново
except Exception as e:
logging.warning(f"HF Dataset: не удалось залить состояние - {e}")
with state._hf_upload_lock:
state._hf_upload_in_progress = False
threading.Thread(target=_upload_loop, 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"]
GRADING_DROP_LEVELS_PCT = [2.0, 4.0, 6.5, 9.0, 12.0] # % просадки от скользящего хая для каждого "грейда" лесенки
GRADING_WEIGHTS = [1.0, 1.0, 1.5, 2.0, 3.0] # относительный вес объема покупки на грейд (глубже просадка -> крупнее докупка, как в твоих grid-EA)
GRADING_RECOVERY_EXIT_PCT = 1.0 # закрываем накопленную позицию, когда цена восстановилась в пределах X% от скользящего хая
# ─────────────────────────────────────────────
# МОДЕЛЬ СЛОТА ПОРТФЕЛЯ
# ─────────────────────────────────────────────
@dataclass
class Slot:
index: int # Индекс слота в портфеле (0, 1, 2...)
symbol: str | None = None # Пара (например, "DOGE/USDT") или None
order_id: str | None = None # ID активного лимитного ордера продажи
order_placed_at: datetime | None = None
bought_qty: float = 0.0
buy_price_avg: float = 0.0
sell_price_set: float = 0.0
usdt_spent: float = 0.0
target_profit_set: float = 0.05 # Целевая прибыль, рассчитанная для конкретной сделки
status: str = "🔍 Поиск" # Отображаемый статус
last_refill_attempt: float = 0.0 # Метка времени для анти-спама
last_known_price: float = 0.0 # Последняя увиденная рыночная цена (для отображения незафиксированного P&L)
last_decay_at: float = 0.0 # Метка времени последнего снижения цели прибыли (убывающий ТП для зависших позиций)
def is_empty(self) -> bool:
return self.symbol is None
def clear(self):
self.symbol = None
self.order_id = None
self.order_placed_at = None
self.bought_qty = 0.0
self.buy_price_avg = 0.0
self.sell_price_set = 0.0
self.usdt_spent = 0.0
self.target_profit_set = 0.05
self.status = "🔍 Поиск"
self.last_known_price = 0.0
self.last_decay_at = 0.0
def to_dict(self) -> dict:
"""Сериализация слота для сохранения на диск (datetime -> ISO-строка)."""
d = asdict(self)
if self.order_placed_at is not None:
d["order_placed_at"] = self.order_placed_at.isoformat()
return d
def load_from_dict(self, d: dict):
"""Восстановление слота из сохраненного словаря. index НЕ трогаем - он привязан к позиции в списке."""
self.symbol = d.get("symbol")
self.order_id = d.get("order_id")
raw_dt = d.get("order_placed_at")
self.order_placed_at = datetime.fromisoformat(raw_dt) if raw_dt else None
self.bought_qty = float(d.get("bought_qty", 0.0))
self.buy_price_avg = float(d.get("buy_price_avg", 0.0))
self.sell_price_set = float(d.get("sell_price_set", 0.0))
self.usdt_spent = float(d.get("usdt_spent", 0.0))
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))
self.last_decay_at = float(d.get("last_decay_at", 0.0))
# ─────────────────────────────────────────────
# ПОТОКОБЕЗОПАСНОЕ СОСТОЯНИЕ БОТА (СИНГЛТОН)
# ─────────────────────────────────────────────
class BotState:
def __init__(self):
self._lock = threading.Lock()
self.slot_lock = threading.RLock() # Защищает мутации Slot от гонки: UI-поток (Panic Sell) vs фоновый trading_loop
self.is_running = False
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
self.use_bnb_discount = True # Флаг скидки комиссии BNB
self.paper_trading = True # Включен ли режим симулятора
self.paper_trades: list[dict] = [] # Полный журнал виртуальных сделок
self.slots: list[Slot] = [Slot(index=i) for i in range(DEFAULT_SLOTS)]
self.logs = []
self.total_profit = 0.0 # Накопленная прибыль сессии
self.trades_count = 0 # Счетчик закрытых сделок (ротаций)
self.last_full_screen_at = 0.0 # Время последнего скрининга
self.market_snapshot = [] # Последние результаты скринера для UI
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 # Использовать адаптивный Тейк-Профит на основе волатильности
self.max_correlation = MAX_CORRELATION_DEFAULT # Порог диверсификации: макс. допустимая корреляция доходностей с уже открытыми/отбираемыми монетами
self.proxy_url = "" # http(s)://user:pass@host:port - обход гео-блокировки Binance для Live (нужен только в Live, paper использует data-api.binance.vision)
self.use_depth_check = True # Проверять глубину стакана перед покупкой, чтобы не покупать в тонкий стакан с большим проскальзыванием
self.max_slippage_pct = 0.5 # Макс. допустимое проскальзывание (%) между лучшим ask и средневзвешенной ценой исполнения нашего объема
# ── Авто-масштабирование слотов по росту депозита ──
self.auto_scale_slots = False # Только Live: раз в час проверяет реальный баланс и добавляет слоты по SLOT_SCALING_TABLE
self.last_autoscale_check_at = 0.0
self.last_symbols_refresh_at = 0.0 # Когда последний раз пересчитывался список разрешенных пар под бюджет
self.initial_deposit = 0.0 # Зафиксированный стартовый депозит (для расчетов авто-масштабирования)
# ── Стратегия "Градация" (альтернатива микро-скальпинг портфелю) ──
self.strategy_engine = "portfolio" # "portfolio" (текущий 5-слотовый микро-скальпинг) | "grading" (лесенка по крупным монетам)
self.grading_symbols = list(GRADING_DEFAULT_SYMBOLS)
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] = [] # метки времени недавних сетевых ошибок (для скользящего окна)
# ── Кэш фильтра старшего тренда (4h) - снижает нагрузку на API ──
self._htf_cache_lock = threading.Lock()
self.htf_trend_cache: dict[str, tuple[float, bool]] = {} # symbol -> (когда проверяли, прошел ли фильтр)
# ── Кэш среднесрочного (1h) трендового фильтра - отдельный от HTF, короче TTL ──
self._mtf_cache_lock = threading.Lock()
self.mtf_trend_cache: dict[str, tuple[float, bool]] = {} # symbol -> (когда проверяли, прошел ли фильтр)
# ── Кэш BTC Market Guard - один результат на весь скрин, а не на каждого кандидата ──
self._btc_guard_lock = threading.Lock()
self.btc_guard_cache: tuple[float, bool, float] | None = None # (когда проверяли, ok?, % изменения BTC)
# ── Персистентность: защита от гонки потоков (UI-клик "Стоп" vs фоновый trading_loop) ──
self._persist_write_lock = threading.Lock() # сериализует запись локального tmp-файла
self._hf_upload_lock = threading.Lock() # см. _push_state_to_hf_dataset
self._hf_upload_in_progress = False
self._hf_upload_pending = False
# ── Защита от повторного холодного старта ──
# ВАЖНО: это НЕ модульная переменная и НЕ st.session_state. Streamlit перевыполняет
# ВЕСЬ файл app.py целиком сверху вниз на КАЖДЫЙ клик/rerun - модульная переменная
# вида "_cold_start_attempted = False" на верхнем уровне файла обнулялась бы на
# КАЖДОМ ререндере (это и было реальным багом: клик "Стоп" тут же откатывался
# обратно в "Автозапуск после рестарта", т.к. защита никогда реально не держалась).
# BotState - синглтон через st.cache_resource и переживает reruns корректно
# (__init__ вызывается ровно один раз за жизнь процесса), поэтому флаг живет здесь.
self._cold_start_lock = threading.Lock()
self._cold_start_attempted = False
def budget_per_slot(self) -> float:
if self.num_slots <= 0:
return 0.0
return self.total_budget / self.num_slots
def fee_rate(self) -> float:
return FEE_RATE_BNB_DISCOUNT if self.use_bnb_discount else FEE_RATE_STANDARD
def log(self, msg: str, level: str = "INFO"):
ts = datetime.now(timezone.utc).strftime("%H:%M:%S")
emoji = {"INFO": "ℹ️", "OK": "✅", "WARN": "⚠️", "ERR": "🔴", "DEAL": "💰"}.get(level, "▪️")
entry = f"[{ts}] {emoji} {msg}"
with self._lock:
self.logs.append(entry)
if len(self.logs) > 300:
self.logs = self.logs[-300:]
logging.info(entry)
def record_paper_trade(self, record: dict):
record["time"] = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S UTC")
with self._lock:
self.paper_trades.append(record)
if len(self.paper_trades) > 500:
self.paper_trades = self.paper_trades[-500:]
def resize_slots(self, new_n: int):
with self._lock:
new_n = max(1, min(MAX_SLOTS, new_n))
current = len(self.slots)
if new_n > current:
self.slots.extend(Slot(index=i) for i in range(current, new_n))
elif new_n < current:
self.slots = self.slots[:new_n]
self.num_slots = new_n
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):
"""
Сохраняет слоты, статистику И параметры торговли на диск + асинхронно в публичный
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,
# "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,
"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 self._persist_write_lock:
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, self)
except Exception as e:
logging.warning(f"Не удалось сохранить состояние на диск: {e}")
@staticmethod
def load_persisted_state() -> dict | None:
"""
Читает сохраненное состояние. Приоритет: сначала пробуем скачать актуальную версию
из публичного 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(path_to_read, "r", encoding="utf-8") as f:
return json.load(f)
except Exception as e:
logging.warning(f"Не удалось прочитать сохраненное состояние: {e}")
return None
@st.cache_resource
def get_bot_state() -> BotState:
return BotState()
# ─────────────────────────────────────────────
# РАБОТА С БИРЖЕЙ
# ─────────────────────────────────────────────
# ─────────────────────────────────────────────
# ИНДИКАТОРЫ
# ─────────────────────────────────────────────
def calculate_rsi(prices: list[float], period: int = 14) -> float:
"""Чистый Python-расчет RSI-14 для избежания внешних C-зависимостей типа TA-Lib"""
if len(prices) < period + 1:
return 50.0
deltas = []
for i in range(1, len(prices)):
deltas.append(prices[i] - prices[i - 1])
gains = [d if d > 0 else 0.0 for d in deltas]
losses = [-d if d < 0 else 0.0 for d in deltas]
avg_gain = sum(gains[:period]) / period
avg_loss = sum(losses[:period]) / period
if avg_loss == 0:
return 100.0
for i in range(period, len(deltas)):
avg_gain = (avg_gain * (period - 1) + gains[i]) / period
avg_loss = (avg_loss * (period - 1) + losses[i]) / period
if avg_loss == 0:
return 100.0
rs = avg_gain / avg_loss
return 100.0 - (100.0 / (1.0 + rs))
def detect_bullish_divergence(closes: list[float], rsi_vals: list[float], window: int = 15) -> tuple[bool, str]:
"""
Ищет бычью дивергенцию (классическую или скрытую) на последних свечах.
Бычья дивергенция (классическая): цена делает более низкое дно (или равное), а RSI - более высокое дно.
Скрытая бычья дивергенция: цена делает более высокое дно, а RSI - более низкое дно (сброс RSI перед ростом).
"""
if len(closes) < 15 or len(rsi_vals) < 15:
return False, "none"
# Ищем впадины (локальные минимумы) за последние 'window' свечей
troughs = []
for i in range(len(closes) - window, len(closes) - 1):
if i <= 0 or i >= len(closes) - 1:
continue
if closes[i] < closes[i-1] and closes[i] < closes[i+1]:
troughs.append(i)
if len(troughs) < 2:
return False, "none"
# Сравниваем две последние впадины
i1 = troughs[-2]
i2 = troughs[-1]
# Если впадины расположены слишком далеко друг от друга (больше 12 свечей), пропускаем
if i2 - i1 > 12:
return False, "none"
p1, p2 = closes[i1], closes[i2]
r1, r2 = rsi_vals[i1], rsi_vals[i2]
# 1. КЛАССИЧЕСКАЯ БЫЧЬЯ ДИВЕРГЕНЦИЯ:
# Цена падает (вторая впадина ниже первой), а RSI растет (вторая впадина на RSI выше первой)
if p2 <= p1 and r2 > r1:
if r2 < 45: # RSI во второй впадине должен быть перепродан
return True, "classic"
# 2. СКРЫТАЯ БЫЧЬЯ ДИВЕРГЕНЦИЯ (сигнал продолжения восходящего тренда после отката):
# Цена растет (вторая впадина выше первой), а RSI падает (вторая впадина на RSI ниже первой)
if p2 > p1 and r2 < r1:
if r2 < 45:
return True, "hidden"
return False, "none"
def calculate_bollinger_bands(prices: list[float], period: int = 20, num_stdDev: float = 2.0) -> tuple[float, float, float]:
"""Чистый Python-расчет Bollinger Bands (Верхняя, Средняя, Нижняя лента) для 1м-свечей"""
if len(prices) < period:
return 0.0, 0.0, 0.0
slice_prices = prices[-period:]
sma = sum(slice_prices) / period
variance = sum((x - sma) ** 2 for x in slice_prices) / period
std_dev = math.sqrt(variance)
upper_band = sma + (num_stdDev * std_dev)
lower_band = sma - (num_stdDev * std_dev)
return upper_band, sma, lower_band
def is_rsi_local_bottom(rsi_array: list[float], lookback: int = 5, confirm_bars: int = RSI_BOTTOM_CONFIRM_BARS) -> bool:
"""
Определяет, развернулся ли RSI вверх после локального минимума.
Требует confirm_bars (по умолчанию 2) ПОДРЯД неубывающих шагов RSI, а не один - единичный
тик вверх на шумной 1m свече слишком легко давал ложный разворот, который тут же гас.
Два (и более) подряд неубывающих шага - более надежное подтверждение начавшегося отскока.
"""
n = len(rsi_array)
if n < lookback + confirm_bars + 1:
return False
# Последние confirm_bars переходов должны быть неубывающими (ни одного отката вниз)
for i in range(n - confirm_bars, n):
if rsi_array[i] < rsi_array[i - 1]:
return False
# Значение, с которого начался этот подъем, должно быть минимумом за окно lookback ДО него
bottom_idx = n - confirm_bars - 1
window = rsi_array[max(0, bottom_idx - lookback):bottom_idx]
if not window:
return False
return rsi_array[bottom_idx] <= min(window)
def safe_call(fn, *args, state: "BotState | None" = None, label: str = "exchange", **kwargs):
"""
Обертка с повторными попытками (retry + экспоненциальный backoff) для сетевых вызовов биржи.
Защищает от падения потока при временных сбоях сети / rate-limit / таймаутах CCXT,
вместо того чтобы просто ловить исключение один раз и терять цикл.
"""
last_err = None
for attempt in range(1, EXCHANGE_RETRY_ATTEMPTS + 1):
try:
return fn(*args, **kwargs)
except (ccxt.NetworkError, ccxt.RequestTimeout, ccxt.DDoSProtection, ccxt.ExchangeNotAvailable) as e:
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:
# Ошибки биржи (неверные параметры, отклоненный ордер и т.п.) ретраить бессмысленно - пробрасываем сразу
raise
raise last_err
def get_returns(closes: list[float]) -> list[float]:
"""Процентные изменения цены свеча-к-свече (доходности) для расчета корреляции."""
if len(closes) < 2:
return []
return [(closes[i] - closes[i - 1]) / closes[i - 1] for i in range(1, len(closes)) if closes[i - 1] != 0]
def calculate_correlation(series_a: list[float], series_b: list[float]) -> float | None:
"""Чистый Python-расчет коэффициента корреляции Пирсона (без numpy), по последним общим N точкам."""
n = min(len(series_a), len(series_b))
if n < 5:
return None
a = series_a[-n:]
b = series_b[-n:]
mean_a = sum(a) / n
mean_b = sum(b) / n
cov = sum((a[i] - mean_a) * (b[i] - mean_b) for i in range(n))
var_a = sum((x - mean_a) ** 2 for x in a)
var_b = sum((x - mean_b) ** 2 for x in b)
denom = math.sqrt(var_a * var_b)
if denom == 0:
return None
return cov / denom
def select_diversified_candidates(
scored: list[dict],
need_n: int,
baseline_closes: list[list[float]],
max_correlation: float,
state: "BotState",
) -> list[dict]:
"""
Жадный отбор кандидатов с фильтром по низкой корреляции доходностей:
- сначала проверяем корреляцию с уже ОТКРЫТЫМИ позициями в других слотах (baseline_closes),
- затем корреляцию между собой (чтобы не набрать 5 слотов из одной "мемной" группы монет).
Если после фильтра не набрали need_n кандидатов - дозаполняем оставшимися лучшими по score,
чтобы не оставлять слоты пустыми (диверсификация - это приоритет, а не жесткий стоп).
"""
selected: list[dict] = []
selected_returns = [get_returns(c) for c in baseline_closes if c]
for cand in scored:
if len(selected) >= need_n:
break
cand_returns = get_returns(cand.get("closes", []))
too_correlated = False
for other_returns in selected_returns:
corr = calculate_correlation(cand_returns, other_returns)
if corr is not None and corr > max_correlation:
too_correlated = True
break
if not too_correlated:
selected.append(cand)
selected_returns.append(cand_returns)
if len(selected) < need_n:
selected_symbols = {c["symbol"] for c in selected}
for cand in scored:
if len(selected) >= need_n:
break
if cand["symbol"] not in selected_symbols:
state.log(f"Диверсификация: не хватило слабокоррелируемых кандидатов, добираем {cand['symbol']} по score", "INFO")
selected.append(cand)
selected_symbols.add(cand["symbol"])
return selected
def estimate_buy_slippage(exchange: ccxt.binance, symbol: str, budget_usdt: float, state: BotState) -> tuple[float, float] | None:
"""
Проверка ГЛУБИНЫ стакана перед покупкой: идем по уровням ask, пока не наберем нужный объем в USDT,
и считаем средневзвешенную цену исполнения. Возвращает (avg_price, slippage_pct) или None при ошибке.
slippage_pct = насколько средняя цена исполнения хуже лучшего ask (в процентах).
Это защищает от покупки в тонкий стакан у низколиквидных монет (score может быть высоким,
а объем в стакане - маленьким, особенно у 1000SATS/DOGS-подобных микро-кап монет).
"""
try:
order_book = safe_call(exchange.fetch_order_book, symbol, 20, state=state, label=f"orderbook {symbol}")
except Exception as e:
state.log(f"Глубина стакана {symbol}: не удалось получить стакан: {e}", "WARN")
return None
asks = order_book.get("asks", [])
if not asks:
return None
best_ask = asks[0][0]
remaining_usdt = budget_usdt
cost_total = 0.0
qty_total = 0.0
for price, qty in asks:
level_usdt = price * qty
take_usdt = min(level_usdt, remaining_usdt)
take_qty = take_usdt / price
cost_total += take_usdt
qty_total += take_qty
remaining_usdt -= take_usdt
if remaining_usdt <= 0:
break
if qty_total == 0 or remaining_usdt > 0:
# Стакан слишком тонкий - даже 20 уровней не покрывают нужный объем
return None
avg_price = cost_total / qty_total
slippage_pct = ((avg_price - best_ask) / best_ask) * 100.0
return avg_price, slippage_pct
def check_book_liquidity_imbalance(exchange: ccxt.binance, symbol: str, current_price: float, state: BotState, min_ratio: float = BOOK_IMBALANCE_MIN_RATIO) -> bool:
"""
Проверяет дисбаланс ликвидности в стакане в пределах BOOK_IMBALANCE_DEPTH_PCT% от текущей
цены: суммарная ликвидность на покупку (bids) должна ощутимо превышать ликвидность на
продажу (asks) - это признак реального спроса ("поддержки") прямо сейчас, а не просто
технического сигнала по свечам. Используется как ДОПОЛНИТЕЛЬНОЕ подтверждение точки входа
поверх RSI/дивергенции/Боллинджера, а не вместо них. min_ratio настраиваемый - для
аномально волатильных ("мем-тир") монет вызывающая сторона передает более строгий порог.
При ошибке сети/пустом стакане - считаем подтверждение не пройденным (безопаснее пропустить
сомнительный вход).
"""
try:
order_book = safe_call(exchange.fetch_order_book, symbol, 50, state=state, label=f"book-imbalance {symbol}")
except Exception as e:
state.log(f"Дисбаланс стакана {symbol}: ошибка получения стакана: {e}", "WARN")
return False
bids = order_book.get("bids", [])
asks = order_book.get("asks", [])
if not bids or not asks or current_price <= 0:
return False
lower_bound = current_price * (1 - BOOK_IMBALANCE_DEPTH_PCT / 100.0)
upper_bound = current_price * (1 + BOOK_IMBALANCE_DEPTH_PCT / 100.0)
bid_liquidity = sum(price * qty for price, qty in bids if price >= lower_bound)
ask_liquidity = sum(price * qty for price, qty in asks if price <= upper_bound)
if bid_liquidity <= 0:
return False
if ask_liquidity <= 0:
return True
ratio = bid_liquidity / ask_liquidity
return ratio >= min_ratio
def compute_target_slots(current_balance: float) -> int:
"""Определяет целевое кол-во слотов по таблице SLOT_SCALING_TABLE - чем больше реальный депозит, тем больше независимых слотов."""
target = DEFAULT_SLOTS
for threshold, slots_n in SLOT_SCALING_TABLE:
if current_balance >= threshold:
target = slots_n
return min(target, MAX_SLOTS)
def maybe_autoscale_slots(exchange: ccxt.binance, state: BotState):
"""
Раз в AUTOSCALE_CHECK_INTERVAL_SEC проверяет РЕАЛЬНЫЙ баланс USDT на бирже (только Live) и,
если депозит вырос до следующего порога в SLOT_SCALING_TABLE - добавляет слоты.
ВАЖНО: только увеличивает количество слотов, никогда не уменьшает автоматически -
уменьшение отрезало бы уже открытые позиции (resize_slots() обрезает список слотов).
"""
if state.paper_trading or not state.auto_scale_slots:
return
now = time.time()
if now - state.last_autoscale_check_at < AUTOSCALE_CHECK_INTERVAL_SEC:
return
state.last_autoscale_check_at = now
try:
balance = safe_call(exchange.fetch_balance, state=state, label="autoscale fetch_balance")
usdt_total = float(balance.get("total", {}).get("USDT", 0) or 0)
except Exception as e:
state.log(f"Авто-масштабирование: ошибка получения баланса: {e}", "WARN")
return
if state.initial_deposit == 0.0:
state.initial_deposit = usdt_total
target = compute_target_slots(usdt_total)
if target > state.num_slots:
old_n = state.num_slots
state.resize_slots(target)
state.total_budget = usdt_total # Пересчитываем общий бюджет под реальный депозит
state.log(f"📈 Авто-масштабирование: депозит ${usdt_total:.2f} -> слотов {old_n} -> {target}", "OK")
def build_exchange(api_key: str, api_secret: str, paper_trading: bool = False, proxy_url: str = "") -> ccxt.binance:
config = {
"apiKey": api_key,
"secret": api_secret,
"options": {
"defaultType": "spot",
"fetchMarkets": ["spot"], # Ограничиваем загрузку только спотовым рынком, чтобы CCXT не опрашивал фьючерсы (fapi/dapi/eapi)
},
"enableRateLimit": True,
}
if paper_trading:
# Для бесплатного симулятора на серверах в США (Hugging Face)
# перенаправляем запросы на официальный незаблокированный шлюз рыночных данных Binance
config["urls"] = {
"api": {
"public": "https://data-api.binance.vision/api/v3",
"private": "https://data-api.binance.vision/api/v3"
}
}
exchange = ccxt.binance(config)
# Обход гео-блокировки Binance для Live-режима (data-api.binance.vision не подходит для приватных
# эндпоинтов - ордера, баланс - там нужен полноценный api.binance.com, который блокирует US-датацентры).
# proxy_url должен указывать на прокси/VPS/туннель, геолоцированный в РАЗРЕШЕННОЙ Binance стране
# (в идеале - в стране, совпадающей с твоим KYC, например Казахстан), иначе есть риск compliance-флага.
if proxy_url:
exchange.proxies = {"http": proxy_url, "https": proxy_url}
return exchange
def execute_grading_buy(exchange: ccxt.binance, symbol: str, budget_usdt: float, grade_idx: int, pos: dict, state: BotState) -> bool:
"""Докупка одного 'грейда' лесенки на просадке крупной монеты. Аналог execute_buy, но без Slot -
накопленная позиция живет в state.grading_positions[symbol], не в портфельных слотах."""
try:
ticker = safe_call(exchange.fetch_ticker, symbol, state=state, label=f"grading buy ticker {symbol}")
ask = ticker.get("ask") or ticker.get("last")
if not ask:
return False
if state.use_depth_check:
depth_result = estimate_buy_slippage(exchange, symbol, budget_usdt, state)
if depth_result is not None:
_, slippage_pct = depth_result
if slippage_pct > state.max_slippage_pct:
state.log(f"Градация {symbol} грейд {grade_idx}: отмена - проскальзывание {slippage_pct:.2f}%", "WARN")
return False
qty = budget_usdt / ask
if state.paper_trading:
state.record_paper_trade({
"symbol": symbol, "action": f"GRADE_BUY_{grade_idx}", "slot": "grading",
"price": ask, "qty": qty, "usdt_value": budget_usdt, "profit": None,
})
else:
order = safe_call(exchange.create_market_buy_order, symbol, qty, state=state, label=f"grading buy {symbol}")
filled_qty = order.get("filled") or qty
avg_price = order.get("average") or ask
state.record_paper_trade({
"symbol": symbol, "action": f"GRADE_BUY_{grade_idx}", "slot": "grading",
"price": avg_price, "qty": filled_qty, "usdt_value": budget_usdt, "profit": None,
})
pos["qty"] += qty
pos["cost"] += budget_usdt
state.log(f"📐 Градация {symbol}: докуплен грейд {grade_idx} (просадка от хая) на ${budget_usdt:.2f} по {ask:.6g}", "OK")
return True
except Exception as e:
state.log(f"Градация {symbol} грейд {grade_idx}: ошибка покупки - {e}", "ERR")
return False
def check_grading_opportunities(exchange: ccxt.binance, state: BotState):
"""
Для каждой монеты из state.grading_symbols проверяет откат от скользящего суточного хая.
Как только просадка достигает следующего незаполненного уровня GRADING_DROP_LEVELS_PCT -
докупает этот грейд (глубже просадка -> крупнее объем, вес из GRADING_WEIGHTS - как лесенка в grid-EA).
За один цикл заполняется максимум ОДИН новый грейд на монету, чтобы не докупить все уровни разом на резком проливе.
"""
if not state.grading_symbols or state.grading_budget <= 0:
return
budget_per_symbol = state.grading_budget / len(state.grading_symbols)
weight_sum = sum(GRADING_WEIGHTS)
for sym in state.grading_symbols:
try:
ticker = safe_call(exchange.fetch_ticker, sym, state=state, label=f"grading scan {sym}")
except Exception as e:
state.log(f"Градация {sym}: ошибка тикера при сканировании - {e}", "WARN")
continue
high24h = ticker.get("high")
last = ticker.get("last") or ticker.get("bid")
if not high24h or not last:
continue
pos = state.grading_positions.setdefault(sym, {"rolling_high": high24h, "filled": set(), "qty": 0.0, "cost": 0.0})
# Скользящий хай обновляем, только если по монете сейчас НЕТ позиции -
# иначе после входа новый локальный хай исказил бы % просадки от точки, где мы уже купили
if not pos["filled"]:
pos["rolling_high"] = max(pos["rolling_high"], high24h)
drop_pct = (pos["rolling_high"] - last) / pos["rolling_high"] * 100.0
for i, level in enumerate(GRADING_DROP_LEVELS_PCT):
if i in pos["filled"]:
continue
if drop_pct >= level:
grade_budget = budget_per_symbol * (GRADING_WEIGHTS[i] / weight_sum)
if execute_grading_buy(exchange, sym, grade_budget, i, pos, state):
pos["filled"].add(i)
break
def process_grading_exits(exchange: ccxt.binance, state: BotState):
"""Закрывает всю накопленную лесенку по монете разом, когда цена восстановилась
в пределах GRADING_RECOVERY_EXIT_PCT % от скользящего хая (почти отросла обратно к максимуму)."""
for sym, pos in list(state.grading_positions.items()):
if pos["qty"] <= 0:
continue
try:
ticker = safe_call(exchange.fetch_ticker, sym, state=state, label=f"grading exit check {sym}")
except Exception as e:
state.log(f"Градация {sym}: ошибка проверки выхода - {e}", "WARN")
continue
last = ticker.get("last") or ticker.get("bid")
if not last:
continue
recovery_price = pos["rolling_high"] * (1 - GRADING_RECOVERY_EXIT_PCT / 100.0)
if last >= recovery_price:
try:
if state.paper_trading:
received = pos["qty"] * last
else:
order = safe_call(exchange.create_market_sell_order, sym, pos["qty"], state=state, label=f"grading sell {sym}")
received = order.get("cost") or (pos["qty"] * last)
profit = received - pos["cost"]
state.record_paper_trade({
"symbol": sym, "action": "GRADE_SELL", "slot": "grading",
"price": last, "qty": pos["qty"], "usdt_value": received, "profit": profit,
})
state.total_profit += profit
state.trades_count += 1
state.log(
f"📐✅ Градация {sym}: лесенка закрыта разом ({len(pos['filled'])} грейдов), "
f"восстановление к хаю, P&L={profit:+.4f} USDT", "OK"
)
except Exception as e:
state.log(f"Градация {sym}: ошибка продажи при выходе - {e}", "ERR")
continue
# Сброс позиции по монете - готова к новому циклу лесенки от нового скользящего хая
state.grading_positions[sym] = {"rolling_high": last, "filled": set(), "qty": 0.0, "cost": 0.0}
def get_allowed_symbols(exchange: ccxt.binance, max_notional: float = MIN_NOTIONAL_FILTER) -> list[str]:
"""
Возвращает пары, где минимальный ордер Binance (minNotional) не превышает max_notional.
ВАЖНО: max_notional теперь передается динамически (обычно = бюджет на слот), а не жестко зашит в 1.0 -
именно жесткая "1.0" была причиной, почему было видно только ~29 монет: у большинства нормальных
монет (не микро-капов) minNotional на Binance составляет 5 или 10 USDT, и они отсекались напрямую.
Чем больше депозит/слот - тем больше пар автоматически становится доступно, без правки кода.
"""
markets = exchange.load_markets()
allowed = []
for sym, info in markets.items():
if not sym.endswith("/USDT"):
continue
if not info.get("active", False):
continue
filters = info.get("info", {}).get("filters", [])
min_notional = None
for f in filters:
if f.get("filterType") in ("MIN_NOTIONAL", "NOTIONAL"):
val = f.get("minNotional") or f.get("notional") or f.get("minQty")
if val is not None:
min_notional = float(val)
break
if min_notional is not None and min_notional <= max_notional:
allowed.append(sym)
return allowed
def _compute_htf_trend_ok(exchange: ccxt.binance, symbol: str, state: BotState) -> bool:
"""
Фильтр старшего тренда (4h) перед входом - защита от "падающих ножей".
Разворотные сигналы на 1m/15m ловят только краткосрочный микро-отскок и ничего не знают
про многодневный тренд: монета может показывать "дно RSI" на 1m, но при этом уже неделю
падать на 4h. Отклоняем вход, только если старший тренд ЯВНО нисходящий (SMA20 на 4h
снижается) И цена уже далеко ниже этой SMA - это отличает "дип в боковике/аптренде"
(нормальный вход) от "лови нож в устойчивом даунтренде" (пропускаем).
Если данных недостаточно/ошибка сети - пропускаем кандидата целиком (безопаснее,
чем входить вслепую без понимания старшего тренда).
"""
try:
ohlcv_4h = safe_call(
exchange.fetch_ohlcv, symbol, HTF_TREND_TIMEFRAME, limit=HTF_TREND_CANDLE_LIMIT,
state=state, label=f"htf-trend {symbol}"
)
except Exception as e:
state.log(f"HTF-тренд {symbol}: ошибка получения {HTF_TREND_TIMEFRAME} свечей: {e}", "WARN")
return False
min_needed = HTF_TREND_SMA_PERIOD + HTF_TREND_SMA_SLOPE_LOOKBACK
if len(ohlcv_4h) < min_needed:
return False
closes_4h = [k[4] for k in ohlcv_4h]
sma_now = sum(closes_4h[-HTF_TREND_SMA_PERIOD:]) / HTF_TREND_SMA_PERIOD
sma_prev_window = closes_4h[-(HTF_TREND_SMA_PERIOD + HTF_TREND_SMA_SLOPE_LOOKBACK):-HTF_TREND_SMA_SLOPE_LOOKBACK]
sma_prev = sum(sma_prev_window) / HTF_TREND_SMA_PERIOD
last_price = closes_4h[-1]
if sma_now <= 0:
return False
below_sma_pct = (sma_now - last_price) / sma_now * 100.0
sma_declining = sma_now < sma_prev
# Отклоняем ТОЛЬКО если тренд старшего ТФ явно падающий И цена уже далеко под ним -
# если SMA растет/плоская, дип ниже нее - это нормальный вход, не блокируем.
if sma_declining and below_sma_pct > HTF_TREND_MAX_BELOW_SMA_PCT:
return False
return True
def check_htf_trend_ok(exchange: ccxt.binance, symbol: str, state: BotState) -> bool:
"""
Кэширующая обертка над _compute_htf_trend_ok. 4h свеча физически не может измениться за
90-270 секунд между скринами, поэтому дергать 4h-эндпоинт на КАЖДОМ цикле для одной и той же
монеты - чистый перерасход лимитов API (именно это внесло вклад в 429 Too Many Requests).
Результат кэшируется на HTF_TREND_CACHE_TTL_SEC (30 минут) на символ.
"""
now = time.time()
with state._htf_cache_lock:
cached = state.htf_trend_cache.get(symbol)
if cached is not None and (now - cached[0]) < HTF_TREND_CACHE_TTL_SEC:
return cached[1]
result = _compute_htf_trend_ok(exchange, symbol, state)
with state._htf_cache_lock:
state.htf_trend_cache[symbol] = (now, result)
return result
def _compute_mtf_trend_ok(exchange: ccxt.binance, symbol: str, state: BotState) -> bool:
"""
Среднесрочный (1h) трендовый фильтр - тот же принцип, что и _compute_htf_trend_ok (наклон SMA
+ отклонение цены под ней), но на более быстром таймфрейме с более коротким периодом. 4h SMA
инертна и не успевает заметно сдвинуться за несколько часов даунтренда - этот фильтр ловит
именно такие "свежие" провалы, которые HTF-фильтр физически не может увидеть вовремя.
"""
try:
ohlcv_mtf = safe_call(
exchange.fetch_ohlcv, symbol, MTF_TREND_TIMEFRAME, limit=MTF_TREND_CANDLE_LIMIT,
state=state, label=f"mtf-trend {symbol}"
)
except Exception as e:
state.log(f"MTF-тренд {symbol}: ошибка получения {MTF_TREND_TIMEFRAME} свечей: {e}", "WARN")
return False
min_needed = MTF_TREND_SMA_PERIOD + MTF_TREND_SMA_SLOPE_LOOKBACK
if len(ohlcv_mtf) < min_needed:
return False
closes_mtf = [k[4] for k in ohlcv_mtf]
sma_now = sum(closes_mtf[-MTF_TREND_SMA_PERIOD:]) / MTF_TREND_SMA_PERIOD
sma_prev_window = closes_mtf[-(MTF_TREND_SMA_PERIOD + MTF_TREND_SMA_SLOPE_LOOKBACK):-MTF_TREND_SMA_SLOPE_LOOKBACK]
sma_prev = sum(sma_prev_window) / MTF_TREND_SMA_PERIOD
last_price = closes_mtf[-1]
if sma_now <= 0:
return False
below_sma_pct = (sma_now - last_price) / sma_now * 100.0
sma_declining = sma_now < sma_prev
# Тот же принцип, что и у HTF: отклоняем ТОЛЬКО если тренд явно падающий И цена уже далеко
# под ним - если SMA растет/плоская, дип ниже нее не блокируем.
if sma_declining and below_sma_pct > MTF_TREND_MAX_BELOW_SMA_PCT:
return False
return True
def check_mtf_trend_ok(exchange: ccxt.binance, symbol: str, state: BotState) -> bool:
"""
Кэширующая обертка над _compute_mtf_trend_ok, по аналогии с check_htf_trend_ok, но с более
коротким TTL (MTF_TREND_CACHE_TTL_SEC) - 1h свеча "устаревает" для наших целей быстрее, чем 4h.
"""
now = time.time()
with state._mtf_cache_lock:
cached = state.mtf_trend_cache.get(symbol)
if cached is not None and (now - cached[0]) < MTF_TREND_CACHE_TTL_SEC:
return cached[1]
result = _compute_mtf_trend_ok(exchange, symbol, state)
with state._mtf_cache_lock:
state.mtf_trend_cache[symbol] = (now, result)
return result
def check_btc_market_guard(exchange: ccxt.binance, state: BotState) -> tuple[bool, float]:
"""
Проверяет, не проваливается ли сам BTC прямо сейчас - системный риск, который per-symbol
HTF/MTF-фильтры (смотрят на тренд КАЖДОЙ монеты отдельно) и диверсификация по корреляции
кандидатов (короткое 30-минутное окно, без BTC как референса) не ловят напрямую. Вызывается
ОДИН раз за весь скрин (не на каждого кандидата) и кэшируется на BTC_GUARD_CACHE_TTL_SEC.
Возвращает (ok, change_pct): ok=False означает, что BTC упал более чем на BTC_GUARD_MAX_DROP_PCT
за последние BTC_GUARD_LOOKBACK свечей BTC_GUARD_TIMEFRAME - новые покупки в Портфеле в этом
цикле приостанавливаются. При ошибке сети/нехватке данных - НЕ блокируем (ok=True), чтобы сбой
получения одной доп. свечи не останавливал торговлю полностью.
"""
now = time.time()
with state._btc_guard_lock:
cached = state.btc_guard_cache
if cached is not None and (now - cached[0]) < BTC_GUARD_CACHE_TTL_SEC:
return cached[1], cached[2]
try:
ohlcv = safe_call(
exchange.fetch_ohlcv, BTC_GUARD_SYMBOL, BTC_GUARD_TIMEFRAME,
limit=BTC_GUARD_LOOKBACK + 1, state=state, label="btc-guard"
)
except Exception as e:
state.log(f"BTC Guard: ошибка получения свечей BTC: {e} - пропускаем проверку (не блокируем вход)", "WARN")
result = (True, 0.0)
with state._btc_guard_lock:
state.btc_guard_cache = (now, result[0], result[1])
return result
if len(ohlcv) < BTC_GUARD_LOOKBACK + 1:
result = (True, 0.0)
with state._btc_guard_lock:
state.btc_guard_cache = (now, result[0], result[1])
return result
closes = [k[4] for k in ohlcv]
ref_price = closes[-1 - BTC_GUARD_LOOKBACK]
last_price = closes[-1]
change_pct = ((last_price - ref_price) / ref_price * 100.0) if ref_price > 0 else 0.0
ok = change_pct > -BTC_GUARD_MAX_DROP_PCT
with state._btc_guard_lock:
state.btc_guard_cache = (now, ok, change_pct)
return ok, change_pct
def screen_full_market(
exchange: ccxt.binance,
allowed_symbols: list[str],
occupied: set[str],
state: BotState,
need_n: int,
) -> list[dict]:
if BTC_GUARD_ENABLED:
btc_ok, btc_change_pct = check_btc_market_guard(exchange, state)
if not btc_ok:
state.log(
f"🛡️ BTC Guard: BTC {btc_change_pct:+.2f}% за последние {BTC_GUARD_LOOKBACK} x {BTC_GUARD_TIMEFRAME} "
f"(лимит -{BTC_GUARD_MAX_DROP_PCT:.2f}%) - рынок падает, новые покупки в Портфеле "
f"приостановлены на этот цикл", "WARN"
)
return []
state.log(f"Полный скрин рынка: {len(allowed_symbols)} разрешенных пар...", "INFO")
try:
# Получаем тикеры для всех пар, так как передача конкретного списка symbols в CCXT
# может вызывать ошибку форматирования (например, пробелы после запятых в JSON) на стороне Binance
all_tickers = safe_call(exchange.fetch_tickers, state=state, label="Скринер fetch_tickers")
tickers = {sym: t for sym, t in all_tickers.items() if sym in allowed_symbols}
except Exception as e:
state.log(f"Скринер: ошибка fetch_tickers: {e}", "ERR")
return []
# Настройка параметров адаптивных фильтров под выбранный режим
if state.strategy_mode.startswith("🛡️"):
rsi_threshold = 32.0 # Только сильная перепроданность
drawdown_mult = 0.20 # Глубокий откат (20% от суточной волатильности)
max_range_pos = 0.45 # Строго в нижней трети диапазона
elif state.strategy_mode.startswith("🔥"):
rsi_threshold = 48.0 # Мягкие условия входа для частых покупок
drawdown_mult = 0.08 # Минимальный откат (8% от волатильности)
max_range_pos = 0.70 # Позволяет брать чуть выше
else: # Сбалансированный
rsi_threshold = 40.0
drawdown_mult = 0.14
max_range_pos = 0.60
candidates = []
for sym, t in tickers.items():
if sym in occupied:
continue
bid = t.get("bid") or 0
ask = t.get("ask") or 0
vol = t.get("quoteVolume") or 0
if bid <= 0 or ask <= 0:
continue
spread = (ask - bid) / bid
if vol < MIN_QUOTE_VOLUME:
continue
if spread > MAX_SPREAD_RATIO:
continue
# Получаем суточные параметры монеты для адаптации
high_24h = t.get("high") or ask
low_24h = t.get("low") or ask
volatility_24h = (high_24h - low_24h) / low_24h if low_24h else 0
candidates.append({
"symbol": sym, "vol": vol, "spread": spread, "ask": ask,
"volatility_24h": volatility_24h, "high_24h": high_24h, "low_24h": low_24h
})
state.log(f"Скрин: {len(candidates)} пар прошли фильтр объема/спреда", "INFO")
if not candidates:
state.log("Скрин: ни одна пара не прошла базовый фильтр", "WARN")
return []
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] = []
for c in batch:
sym = c["symbol"]
# ─── МУЛЬТИТАЙМФРЕЙМОВЫЙ АНАЛИЗ (1h → 15m → 1m) ───
# Шаг А: Анализ на ЧАСОВОМ таймфрейме ("1h") - оценка макро-тренда
try:
ohlcv_1h = safe_call(exchange.fetch_ohlcv, sym, "1h", limit=15, state=state, label=f"1h {sym}")
except Exception as e:
state.log(f"Скрин: ошибка 1h свечей {sym}: {e}", "WARN")
continue
if len(ohlcv_1h) < 15:
continue
closes_1h = [k[4] for k in ohlcv_1h]
rsi_1h = calculate_rsi(closes_1h, period=14)
# Вместо жесткой часовой отсечки, которая полностью блокирует сделки на растущем рынке,
# мы фильтруем только экстремальную перегрутость (RSI > 75) или умирающие монеты (RSI < 25)
if rsi_1h > 75.0 or rsi_1h < 25.0:
continue
# ── Фильтр старшего тренда (4h) - защита от "падающих ножей" ──
# Проверяем ДО дорогих 15m/1m запросов - если монета в структурном даунтренде,
# нет смысла тратить лимиты API на детальный анализ входа.
if not check_htf_trend_ok(exchange, sym, state):
continue
# ── Среднесрочный фильтр тренда (1h) - ловит свежие провалы, которые 4h SMA еще не видит ──
if MTF_TREND_FILTER_ENABLED and not check_mtf_trend_ok(exchange, sym, state):
continue
# Шаг Б: Дивергенция на 15-МИНУТНОМ таймфрейме - более надежный сигнал разворота,
# чем на 1m (там слишком много рыночного шума для впадин цены/RSI)
try:
ohlcv_15m = safe_call(exchange.fetch_ohlcv, sym, "15m", limit=40, state=state, label=f"15m {sym}")
except Exception as e:
state.log(f"Скрин: ошибка 15m свечей {sym}: {e}", "WARN")
continue
if len(ohlcv_15m) < 20:
continue
closes_15m = [k[4] for k in ohlcv_15m]
rsi_array_15m = []
for i in range(len(closes_15m)):
rsi_array_15m.append(calculate_rsi(closes_15m[:i+1], period=14))
has_divergence, div_type = detect_bullish_divergence(closes_15m, rsi_array_15m, window=15)
# Доп. подтверждение: дивергенция засчитывается как сигнал, только если RSI(15m) на момент
# сигнала все еще отчетливо в зоне перепроданности - см. RSI_15M_DIVERGENCE_CONFIRM_ENABLED
if RSI_15M_DIVERGENCE_CONFIRM_ENABLED and has_divergence and rsi_array_15m[-1] >= RSI_15M_DIVERGENCE_CONFIRM_MAX:
has_divergence = False
# Шаг В: Точный тайминг входа на МИНУТНОМ таймфрейме ("1m") - Боллинджер + "дно" RSI
try:
ohlcv_1m = safe_call(exchange.fetch_ohlcv, sym, "1m", limit=CANDLE_LIMIT, state=state, label=f"1m {sym}")
except Exception as e:
state.log(f"Скрин: ошибка 1m свечей {sym}: {e}", "WARN")
continue
if len(ohlcv_1m) < 15:
continue
closes_1m = [k[4] for k in ohlcv_1m]
highs_1m = [k[2] for k in ohlcv_1m]
lows_1m = [k[3] for k in ohlcv_1m]
opens_1m = [k[1] for k in ohlcv_1m]
high_max_1m = max(highs_1m)
low_min_1m = min(lows_1m)
# Вычисляем массив исторических значений RSI-14 для 1м свечей
rsi_array_1m = []
for i in range(len(closes_1m)):
rsi_array_1m.append(calculate_rsi(closes_1m[:i+1], period=14))
rsi_val_1m = rsi_array_1m[-1]
# "На самом дне" = RSI(1m) только что обновил локальный минимум за последние RSI_BOTTOM_LOOKBACK баров
# И УЖЕ начал разворачиваться вверх (текущее значение >= предыдущего) - это отличает точку входа
# от "ловли падающего ножа": мы ждем не саму просадку, а момент, когда просадка останавливается.
is_rsi_bottom = is_rsi_local_bottom(rsi_array_1m, lookback=RSI_BOTTOM_LOOKBACK, confirm_bars=RSI_BOTTOM_CONFIRM_BARS)
# Рассчитываем ленты Боллинджера на 1м (период 20, StdDev 2.0)
_, _, lower_band = calculate_bollinger_bands(closes_1m, period=20, num_stdDev=2.0)
# АДАПТИВНЫЙ ПОРОГ RSI-1m: если часовой тренд сильный, мы повышаем порог RSI-1m для легкого входа на откатах.
# Если часовой тренд слабый/падающий, мы ужесточаем порог RSI-1m для защиты от "падающих ножей".
dynamic_rsi_threshold = rsi_threshold + (rsi_1h - 50.0) * 0.25
dynamic_rsi_threshold = max(28.0, min(52.0, dynamic_rsi_threshold))
is_entry_triggered = False
if state.strategy_mode.startswith("🛡️"):
# 🛡️ Консервативный: дивергенция на 15m при перепроданности + дно RSI на 1m + касание нижней ленты Боллинджера
if has_divergence and is_rsi_bottom and rsi_val_1m <= dynamic_rsi_threshold and c["ask"] <= lower_band:
range_position = (c["ask"] - low_min_1m) / (high_max_1m - low_min_1m) if (high_max_1m - low_min_1m) > 0 else 0
if range_position <= max_range_pos:
is_entry_triggered = True
elif state.strategy_mode.startswith("🔥"):
# 🔥 Агрессивный: дно RSI на 1m (в разумной зоне), ИЛИ дивергенция на 15m, ИЛИ пробой ленты Боллинджера
if (is_rsi_bottom and rsi_val_1m <= dynamic_rsi_threshold) or has_divergence or c["ask"] <= lower_band:
is_entry_triggered = True
else:
# ⚖️ Сбалансированный: дивергенция на 15m, либо (дно RSI на 1m + зеленая свеча), либо пробой нижней ленты Боллинджера
range_position = (c["ask"] - low_min_1m) / (high_max_1m - low_min_1m) if (high_max_1m - low_min_1m) > 0 else 0
if range_position <= max_range_pos:
if has_divergence:
is_entry_triggered = True
elif rsi_val_1m <= dynamic_rsi_threshold and closes_1m[-1] > opens_1m[-1]:
is_entry_triggered = True
elif c["ask"] <= lower_band:
is_entry_triggered = True
if not is_entry_triggered:
continue
# ── Фильтр скорости падения (защита от входа в еще активно падающую монету) ──
# Разворотные сигналы выше могли сработать на одной свече, даже если цена в моменте
# продолжает активно падать. closes_1m уже загружены для RSI/Боллинджера - доп. запрос
# к API не нужен. Если падение за последние FREEFALL_LOOKBACK_CANDLES 1m свечей все еще
# превышает FREEFALL_MAX_DROP_PCT - входа не будет, независимо от остальных сигналов.
if FREEFALL_GUARD_ENABLED and len(closes_1m) > FREEFALL_LOOKBACK_CANDLES:
ref_price = closes_1m[-1 - FREEFALL_LOOKBACK_CANDLES]
if ref_price > 0:
recent_change_pct = (closes_1m[-1] - ref_price) / ref_price * 100.0
if recent_change_pct <= -FREEFALL_MAX_DROP_PCT:
continue
# ── "Мем-тир": аномально волатильные монеты требуют более строгого подтверждения ──
# Определяем ПО ПОВЕДЕНИЮ (суточная волатильность), а не по хрупкому списку тикеров -
# кейс PUMP показал, что на таких монетах RSI-дно + обычный всплеск объема могут
# сработать на ложный, манипулятивный импульс, а не на реальный разворот.
is_meme_tier = c["volatility_24h"] >= HIGH_VOLATILITY_MEME_THRESHOLD
vol_multiplier = MEME_TIER_VOLUME_MULTIPLIER if is_meme_tier else VOLUME_CONFIRMATION_MULTIPLIER
book_min_ratio = MEME_TIER_BOOK_MIN_RATIO if is_meme_tier else BOOK_IMBALANCE_MIN_RATIO
# ── Подтверждение объемом ──
# Разворотные индикаторы (RSI-дно, дивергенция, Боллинджер) сами по себе НЕ отличают
# "настоящий отскок с реальным спросом" от "монета просто затихла и продолжит валиться
# дальше на тонком объеме". Требуем, чтобы объем на последней 1m свече был заметно выше
# среднего за последние VOLUME_CONFIRMATION_LOOKBACK свечей - это признак того, что в
# разворот заходит реальный объем покупателей, а не штиль перед новым проливом.
# Для мем-тира порог заметно строже (vol_multiplier).
if VOLUME_CONFIRMATION_ENABLED:
volumes_1m = [k[5] for k in ohlcv_1m]
vol_window = volumes_1m[-(VOLUME_CONFIRMATION_LOOKBACK + 1):-1]
avg_vol = sum(vol_window) / len(vol_window) if vol_window else 0
last_vol = volumes_1m[-1]
if avg_vol <= 0 or last_vol < avg_vol * vol_multiplier:
continue
# Вычисляем адаптивную просадку на основе суточной волатильности
adaptive_min_drawdown = max(0.006, c["volatility_24h"] * drawdown_mult)
drawdown = (high_max_1m - c["ask"]) / high_max_1m
if drawdown < adaptive_min_drawdown:
continue
# Верхняя граница - слишком глубокая просадка за 30 минут похожа на обвал, а не на дип
if drawdown > MAX_DRAWDOWN_FROM_1M_HIGH_PCT / 100.0:
continue
# ── Дисбаланс ликвидности в стакане ──
# Технические индикаторы работают только со свечами - они не видят реальный СПРОС на
# покупку прямо сейчас. Проверяем стакан: если ниже текущей цены (bids) заметно больше
# ликвидности, чем выше нее (asks) в пределах BOOK_IMBALANCE_DEPTH_PCT% - это похоже на
# реальную поддержку от покупателей. Если наоборот (по факту сверху густой навес на
# продажу) - монете, скорее всего, еще есть куда падать даже после "дна" по индикаторам.
# Проверяем это ПОСЛЕДНИМ (после всех остальных, более дешевых фильтров), т.к. это
# отдельный сетевой запрос стакана на каждого кандидата, а до этой строки доходят уже
# немногие. Для мем-тира требуем более выраженный перевес (book_min_ratio).
if BOOK_IMBALANCE_ENABLED:
if not check_book_liquidity_imbalance(exchange, sym, c["ask"], state, min_ratio=book_min_ratio):
continue
# Считаем итоговый скоринг (чем ниже rsi_1h и rsi_val_1m, тем выше балл)
# ВАЖНО: math.sqrt(drawdown), а не drawdown линейно. Линейный drawdown в числителе
# систематически отдавал предпочтение монетам с САМЫМ экстремальным падением среди всех
# кандидатов, прошедших фильтры - а именно такие монеты (в т.ч. force-include "самой
# просевшей" ниже) статистически чаще оказываются настоящим обвалом (долго/не
# восстанавливаются), чем "здоровым" дипом с тем же качеством остальных сигналов
# (объем/спред/RSI). sqrt() сглаживает этот перекос, не убирая фактор просадки из скоринга.
score = (math.sqrt(drawdown) * math.log10(c["vol"])) / (c["spread"] * (rsi_val_1m / 50.0))
scored.append({
"symbol": sym, "score": score, "ask": c["ask"],
"volume": c["vol"], "spread": c["spread"], "drawdown": drawdown,
"rsi": rsi_val_1m, "volatility_24h": c["volatility_24h"],
"closes": closes_1m, # доходности для последующего расчета корреляции (диверсификация слотов)
})
scored.sort(key=lambda x: x["score"], reverse=True)
state.market_snapshot = scored[:10]
if not scored:
state.log("Скрин: ни одна монета не прошла адаптивные индикаторы", "WARN")
# Возвращаем ПОЛНЫЙ ранжированный список (не обрезаем до need_n) -
# финальный отбор с фильтром по корреляции делает вызывающая сторона (refill_empty_slots)
return scored
def execute_buy(exchange: ccxt.binance, symbol: str, budget_usdt: float, slot: Slot, state: BotState) -> bool:
try:
# fetch_ticker - безопасно ретраить (чтение, без побочных эффектов на бирже)
ticker = safe_call(exchange.fetch_ticker, symbol, state=state, label=f"buy ticker {symbol}")
ask = ticker["ask"]
if not ask or ask <= 0:
state.log(f"[Слот {slot.index}] Buy: некорректный Ask для {symbol}", "ERR")
return False
raw_qty = budget_usdt / ask
qty = float(exchange.amount_to_precision(symbol, raw_qty))
notional = qty * ask
if notional < 1.0:
state.log(f"[Слот {slot.index}] Buy: notional={notional:.4f} < 1.0 USDT - пропуск", "ERR")
return False
# ── Проверка глубины стакана (защита от проскальзывания на тонких стаканах) ──
if state.use_depth_check:
depth_result = estimate_buy_slippage(exchange, symbol, budget_usdt, state)
if depth_result is None:
state.log(f"[Слот {slot.index}] Buy {symbol}: не удалось оценить глубину стакана - пропуск (осторожность)", "WARN")
return False
avg_depth_price, slippage_pct = depth_result
if slippage_pct > state.max_slippage_pct:
state.log(
f"[Слот {slot.index}] Buy {symbol}: ОТМЕНА - проскальзывание {slippage_pct:.2f}% "
f"> лимита {state.max_slippage_pct:.2f}% (стакан слишком тонкий для ${budget_usdt:.2f})", "WARN"
)
return False
if state.paper_trading:
filled = qty
avg_cost = qty * ask
avg_px = ask
state.log(
f"📝 [PAPER][Слот {slot.index}] Buy {symbol}: qty={qty}, ask={ask} (РЕАЛЬНАЯ цена), "
f"notional approx {notional:.4f} - виртуально, без реального ордера", "INFO"
)
state.record_paper_trade({
"symbol": symbol, "action": "buy", "slot": slot.index,
"price": avg_px, "qty": filled, "usdt_value": avg_cost, "profit": None
})
else:
state.log(f"[Слот {slot.index}] Buy {symbol}: qty={qty}, ask={ask}, notional approx {notional:.4f}", "INFO")
# ВАЖНО: create_market_buy_order намеренно НЕ через safe_call/ретрай.
# Если сеть оборвется уже ПОСЛЕ того, как биржа приняла ордер, слепой повтор
# рискует купить в 2 раза больше запланированного (двойной вход на слот).
# Один неудавшийся вход - не страшно (просто пропустим цикл), а вот
# задвоенная покупка - реальная потеря контроля над бюджетом на слот.
order = exchange.create_market_buy_order(symbol, qty)
filled = float(order.get("filled") or qty)
avg_cost = float(order.get("cost") or (qty * ask))
avg_px = avg_cost / filled if filled > 0 else ask
# Рассчитываем целевую прибыль под волатильность конкретной монеты (Адаптивный Тейк-Профит)
if state.use_dynamic_tp:
high24h = ticker.get("high") or ask
low24h = ticker.get("low") or ask
volatility_24h = (high24h - low24h) / low24h if low24h else 0
# Тейк-Профит составит от 0.5% до 2.5% от суммы сделки в зависимости от суточных колебаний
tp_percent = max(0.005, min(0.025, volatility_24h * 0.12))
deal_profit = avg_cost * tp_percent
state.log(f"[Слот {slot.index}] Адаптивный Тейк-Профит для {symbol}: {tp_percent*100:.2f}% (цель profit: {deal_profit:.4f} USDT)", "INFO")
else:
deal_profit = state.target_profit
slot.symbol = symbol
slot.bought_qty = filled
slot.buy_price_avg = avg_px
slot.usdt_spent = avg_cost
slot.target_profit_set = deal_profit
state.log(
f"[Слот {slot.index}] Buy исполнен: {filled} {symbol.replace('/USDT','')} "
f"по approx {avg_px:.6f}, потрачено {avg_cost:.4f} USDT", "OK"
)
state.save_persisted_state()
return True
except Exception as e:
state.log(f"[Слот {slot.index}] Buy ОШИБКА: {e}", "ERR")
return False
def place_limit_sell(exchange: ccxt.binance, slot: Slot, state: BotState) -> bool:
try:
symbol = slot.symbol
fee = state.fee_rate()
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))
notional = qty * sell_px
if notional < 1.0:
state.log(f"[Слот {slot.index}] LimitSell: notional={notional:.4f} < 1.0 - пропуск", "ERR")
return False
if state.paper_trading:
order_id = f"PAPER-{uuid.uuid4().hex[:10]}"
state.log(
f"📝 [PAPER][Слот {slot.index}] LimitSell {symbol}: qty={qty}, price={sell_px:.6f} "
f"(виртуальный ордер {order_id}) - ожидание достижения цены", "INFO"
)
else:
state.log(
f"[Слот {slot.index}] LimitSell {symbol}: qty={qty}, price={sell_px:.6f}, "
f"notional={notional:.4f}, target_profit={slot.target_profit_set:.4f}", "INFO"
)
# Продажа уже КУПЛЕННОЙ монеты - повторная попытка при сетевом сбое безопаснее,
# чем при покупке: худший случай - вторая попытка получит "insufficient balance",
# т.к. монета уже зарезервирована первым (успешным) ордером.
order = safe_call(exchange.create_limit_sell_order, symbol, qty, sell_px, state=state, label=f"limit sell {symbol}")
order_id = order["id"]
slot.order_id = order_id
slot.order_placed_at = datetime.now(timezone.utc)
slot.sell_price_set = sell_px
slot.status = "⏳ Ждем продажи"
state.log(f"[Слот {slot.index}] LimitSell выставлен: ID={order_id}, цена={sell_px:.6f}", "OK")
state.save_persisted_state()
return True
except Exception as e:
state.log(f"[Слот {slot.index}] LimitSell ОШИБКА: {e}", "ERR")
return False
def maybe_decay_stale_target(exchange: ccxt.binance, slot: Slot, state: BotState):
"""
Для позиций, которые висят намного дольше обычного и до сих пор не достигли цели продажи,
постепенно СНИЖАЕТ требуемую прибыль (target_profit_set), а затем перевыставляет лимит-ордер
по новой, более скромной цели. Это НЕ стоп-лосс - мы никогда не продаем принудительно в
минус, просто со временем делаем изначально заданную цель прибыли менее оптимистичной, чтобы
позиции было легче закрыться (например, в 0.02 USDT профита вместо изначальных 0.09), а не
ждать полного отката цены к исходному таргету неделями. Никогда не опускает цель ниже
STALE_POSITION_MIN_PROFIT_FLOOR_PCT % от суммы сделки. Применяется не чаще, чем раз в
STALE_POSITION_DECAY_INTERVAL_MIN минут на слот (не спамит переустановку ордера).
"""
if not slot.order_placed_at:
return
elapsed_min = (datetime.now(timezone.utc) - slot.order_placed_at).total_seconds() / 60.0
if elapsed_min < STALE_POSITION_DECAY_START_MIN:
return
now = time.time()
if now - slot.last_decay_at < STALE_POSITION_DECAY_INTERVAL_MIN * 60:
return
floor_profit = slot.usdt_spent * (STALE_POSITION_MIN_PROFIT_FLOOR_PCT / 100.0)
if slot.target_profit_set <= floor_profit * 1.001:
slot.last_decay_at = now # уже на полу - не пересчитываем зря каждый цикл, но и не спамим лог
return
old_target_profit = slot.target_profit_set
new_target_profit = max(floor_profit, slot.target_profit_set * (1 - STALE_POSITION_DECAY_STEP_PCT))
slot.target_profit_set = new_target_profit
slot.last_decay_at = now
state.log(
f"[Слот {slot.index}] 📉 Убывающий ТП: {slot.symbol} висит {elapsed_min:.0f}м без исполнения, "
f"снижаю цель прибыли {old_target_profit:.4f} -> {new_target_profit:.4f} USDT "
f"(минимальный пол: {floor_profit:.4f})", "WARN"
)
if not state.paper_trading and slot.order_id:
try:
safe_call(exchange.cancel_order, slot.order_id, slot.symbol, state=state, label=f"decay cancel {slot.symbol}")
except Exception as e:
state.log(f"[Слот {slot.index}] Убывающий ТП: не удалось отменить старый ордер: {e} - пробую перевыставить все равно", "WARN")
if not place_limit_sell(exchange, slot, state):
state.log(f"[Слот {slot.index}] Убывающий ТП: не удалось выставить новый лимит-ордер -> экстренная продажа", "ERR")
panic_sell_slot(exchange, slot, state, prefix="🚨 PANIC")
def panic_sell_slot(exchange: ccxt.binance, slot: Slot, state: BotState, prefix: str = "🚨 PANIC") -> bool:
"""Обертка над _panic_sell_slot_impl: гарантирует сохранение состояния на диск
при любом исходе (успех/ошибка), не дублируя save_persisted_state() на каждый return."""
try:
return _panic_sell_slot_impl(exchange, slot, state, prefix)
finally:
state.save_persisted_state()
def _panic_sell_slot_impl(exchange: ccxt.binance, slot: Slot, state: BotState, prefix: str = "🚨 PANIC") -> bool:
"""
Продает позицию слота (по рынку) и очищает слот - но ТОЛЬКО если продажа реально прошла
или на балансе уже нечего продавать. Если рыночная продажа падает с ошибкой, слот НЕ
очищается: symbol/bought_qty/buy_price_avg/usdt_spent остаются как есть, чтобы бот не
"забывал" про реально купленную монету, пока она физически висит на балансе биржи.
Возвращает True, если позиция закрыта (слот очищен), False - если нужна повторная попытка.
"""
sym = slot.symbol
state.log(f"{prefix} [Слот {slot.index}]: принудительный/таймаут выход из {sym}", "WARN")
if state.paper_trading:
try:
ticker = safe_call(exchange.fetch_ticker, sym, state=state, label=f"panic ticker {sym}")
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": action_type, "slot": slot.index,
"price": current_bid, "qty": slot.bought_qty,
"usdt_value": received, "profit": loss,
})
except Exception as e:
state.log(
f"📝 {prefix} [Слот {slot.index}]: ошибка получения цены для виртуального выхода: {e} - "
f"слот НЕ очищен, повтори выход вручную", "ERR"
)
slot.status = f"🔴 Ошибка выхода ({prefix}) - повтори Panic Sell"
return False
slot.clear()
return True
if slot.order_id:
try:
safe_call(exchange.cancel_order, slot.order_id, sym, state=state, label=f"panic cancel {sym}")
state.log(f"{prefix} [Слот {slot.index}]: лимит ID={slot.order_id} отменен", "OK")
except Exception as e:
# Не критично само по себе (ордер мог уже исполниться раньше) - пробуем продать
# реальный остаток на балансе несмотря на эту ошибку
state.log(f"{prefix} [Слот {slot.index}]: ошибка отмены лимитного ордера: {e}", "WARN")
time.sleep(1)
try:
base = sym.split("/")[0]
balance = safe_call(exchange.fetch_balance, state=state, label=f"panic balance {base}")
qty_free = float(balance["free"].get(base, 0))
if qty_free <= 0:
state.log(f"{prefix} [Слот {slot.index}]: баланс {base}={qty_free} - нечего продавать (позиция уже закрыта)", "WARN")
slot.clear()
return True
qty_sell = float(exchange.amount_to_precision(sym, qty_free))
order = safe_call(exchange.create_market_sell_order, sym, qty_sell, state=state, label=f"panic sell {sym}")
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"
)
slot.clear()
return True
except Exception as e:
state.log(
f"{prefix} [Слот {slot.index}]: ОШИБКА рыночной продажи - {e}. Слот НЕ очищен: "
f"{sym} и его цена покупки остаются под учетом бота, чтобы позиция не потерялась. "
f"Проверь баланс на бирже вручную и повтори Panic Sell.", "ERR"
)
slot.status = f"🔴 Ошибка выхода ({prefix}) - повтори Panic Sell вручную!"
return False
def fetch_baseline_closes(exchange: ccxt.binance, occupied_symbols: set[str], state: BotState) -> list[list[float]]:
"""Подтягивает свежие 1m closes по уже ОТКРЫТЫМ позициям - нужно как база для расчета корреляции
новых кандидатов с тем, что уже куплено в других слотах (чтобы не набрать портфель из коррелирующих монет)."""
baseline = []
for sym in occupied_symbols:
try:
ohlcv = safe_call(exchange.fetch_ohlcv, sym, "1m", limit=CORRELATION_LOOKBACK, state=state, label=f"baseline {sym}")
closes = [k[4] for k in ohlcv]
if closes:
baseline.append(closes)
except Exception as e:
state.log(f"Диверсификация: не удалось получить свечи {sym} для расчета корреляции: {e}", "WARN")
return baseline
def refill_empty_slots(exchange: ccxt.binance, allowed_symbols: list[str], empty_slots: list[Slot], state: BotState):
"""Выполняет один общий пакетный скрин рынка для всех пустых слотов сразу,
с отбором кандидатов по принципу слабой корреляции (диверсификация портфеля слотов)."""
now = time.time()
# Фильтруем слоты, готовые к наполнению
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
for slot in slots_to_refill:
slot.last_refill_attempt = now
slot.status = "🔍 Поиск замены"
occupied = state.occupied_symbols()
need_n = len(slots_to_refill)
# Полный ранжированный список кандидатов (score desc), без обрезки
scored = screen_full_market(exchange, allowed_symbols, occupied, state, need_n=need_n)
if not scored:
for slot in slots_to_refill:
slot.status = "🔍 Поиск"
state.log(f"Нет подходящих кандидатов в этом цикле для {need_n} пустых слотов", "INFO")
return
# Слабокоррелируемый отбор: сравниваем доходности кандидатов с уже открытыми позициями + друг с другом
baseline_closes = fetch_baseline_closes(exchange, occupied, state) if occupied else []
candidates = select_diversified_candidates(
scored, need_n, baseline_closes, state.max_correlation, state
)
names = ", ".join(f"{x['symbol']}(score={x['score']:.1f}, rsi={x['rsi']:.1f})" for x in candidates)
state.log(f"Скрин: выбрано {len(candidates)} кандидатов (диверсификация ≤{state.max_correlation:.2f}) -> {names}", "OK")
# Заполняем слоты найденными кандидатами (мутации слота - под локом, слот живет независимо от других)
for slot, best in zip(slots_to_refill, candidates):
with state.slot_lock:
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()
state.save_persisted_state()
# ─────────────────────────────────────────────
# ГЛАВНЫЙ ЦИКЛ ПОЛЛИНГА
# ─────────────────────────────────────────────
def process_occupied_slot(exchange: ccxt.binance, slot: Slot, state: BotState):
"""Обрабатывает один занятый слот: проверка тайм-аута/ротации/статуса ордера.
Вызывается под state.slot_lock, чтобы не пересекаться с UI-потоком (Panic Sell).
Каждый слот обрабатывается и живет полностью независимо от остальных."""
if slot.is_empty():
return
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, prefix="⏰ TIMEOUT")
return
# 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")
return
except Exception as e:
state.log(f"[Слот {slot.index}] Ошибка при расчете плюсовой ротации: {e}", "WARN")
# 3. Убывающий тейк-профит для зависших позиций (НЕ выход по рынку - просто смягчение
# изначально заданной цели прибыли, чтобы облегчить закрытие вместо бесконечного ожидания)
maybe_decay_stale_target(exchange, slot, state)
try:
if state.paper_trading:
ticker = exchange.fetch_ticker(slot.symbol)
current_bid = ticker.get("bid") or ticker.get("last") or 0
if current_bid >= slot.sell_price_set:
received = slot.bought_qty * slot.sell_price_set
profit = received - slot.usdt_spent
state.total_profit += profit
state.trades_count += 1
state.log(
f"📝 [PAPER][Слот {slot.index}] ВИРТУАЛЬНАЯ СДЕЛКА ЗАКРЫТА: {slot.symbol}, "
f"реальная цена рынка {current_bid:.6g} достигла цели {slot.sell_price_set:.6g}, "
f"прибыль approx {profit:.4f} USDT 🎉", "DEAL"
)
state.record_paper_trade({
"symbol": slot.symbol, "action": "sell", "slot": slot.index,
"price": slot.sell_price_set, "qty": slot.bought_qty,
"usdt_value": received, "profit": profit,
})
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)
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 " (безлимит)"
slot.status = f"⏳📝 {current_bid:.6g} -> {slot.sell_price_set:.6g} ({elapsed_min}м{timeout_str})"
return
order = exchange.fetch_order(slot.order_id, slot.symbol)
status = order.get("status", "")
if status == "closed":
received = float(order.get("cost") or 0)
profit = received - slot.usdt_spent
state.total_profit += profit
state.trades_count += 1
state.log(
f"[Слот {slot.index}] СДЕЛКА ЗАКРЫТА: {slot.symbol}, "
f"куплено={slot.usdt_spent:.4f}, продано={received:.4f}, "
f"прибыль approx {profit:.4f} USDT 🎉", "DEAL"
)
slot.clear()
state.save_persisted_state()
elif status in ("canceled", "expired"):
state.log(f"[Слот {slot.index}] Ордер отменен/просрочен извне — выход по рынку", "WARN")
panic_sell_slot(exchange, slot, state)
else:
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}м")
if state.use_profit_exit:
timeout_parts.append(f"плюс-ротация > {state.profit_exit_timeout_min}м")
timeout_str = " (" + " | ".join(timeout_parts) + ")" if timeout_parts else " (безлимит)"
slot.status = f"⏳ -> {slot.sell_price_set:.6g} ({elapsed_min}м{timeout_str})"
except Exception as e:
state.log(f"[Слот {slot.index}] Ошибка проверки ордера: {e}", "WARN")
def reconcile_persisted_slots(exchange: ccxt.binance, state: BotState):
"""
Восстанавливает слоты из файла на диске (переживших рестарт процесса/контейнера) и,
для Live-режима, сверяет их с РЕАЛЬНЫМ балансом на бирже, прежде чем бот продолжит
торговать - файлу вслепую не доверяем, т.к. позиция могла быть закрыта вручную,
пока бот не работал.
"""
saved = state.load_persisted_state()
if not saved:
state.log("Персистентность: сохраненного состояния слотов не найдено - стартуем с чистого листа", "INFO")
return
if saved.get("paper_trading") != state.paper_trading:
state.log(
"Персистентность: сохраненное состояние относится к другому режиму (paper/live) - "
"восстановление ПРОПУЩЕНО ради безопасности", "WARN"
)
return
saved_slots = saved.get("slots", [])
restored_n = 0
for i, slot in enumerate(state.slots):
if i >= len(saved_slots):
continue
sdict = saved_slots[i]
if not sdict.get("symbol"):
continue # слот был пуст на момент сохранения - восстанавливать нечего
slot.load_from_dict(sdict)
restored_n += 1
if state.paper_trading:
# Виртуальная позиция - восстанавливаем как есть, цена дальше берется из реального рынка
slot.status = f"♻️ Восстановлено после рестарта: {slot.symbol}"
continue
# ── Live: сверяем с реальным балансом на бирже ──
try:
base = slot.symbol.split("/")[0]
balance = safe_call(exchange.fetch_balance, state=state, label=f"reconcile balance {base}")
qty_total = float(balance.get("total", {}).get(base, 0) or 0)
except Exception as e:
state.log(f"[Слот {slot.index}] Сверка после рестарта: ошибка баланса {e} - слот НЕ восстановлен (безопасность)", "ERR")
slot.clear()
continue
if qty_total < slot.bought_qty * 0.9:
state.log(
f"[Слот {slot.index}] Сверка после рестарта: на балансе {base}={qty_total:.6g}, "
f"а по записи должно быть ~{slot.bought_qty:.6g} - позиция уже закрыта помимо бота "
f"(продана вручную или файл устарел). Слот очищен.", "WARN"
)
slot.clear()
continue
# Монета на месте - проверяем, жив ли лимитный ордер на продажу
order_alive = False
if slot.order_id:
try:
order = safe_call(exchange.fetch_order, slot.order_id, slot.symbol, state=state, label=f"reconcile order {slot.symbol}")
order_alive = order.get("status") == "open"
except Exception:
order_alive = False
if order_alive:
slot.status = f"♻️ Восстановлено после рестарта: {slot.symbol} (лимит-ордер на месте)"
state.log(
f"[Слот {slot.index}] Сверка после рестарта: {slot.symbol} на балансе, "
f"лимит-ордер ID={slot.order_id} все еще открыт - продолжаем как обычно", "OK"
)
else:
state.log(
f"[Слот {slot.index}] Сверка после рестарта: {slot.symbol} на балансе, но лимит-ордер "
f"не найден/не открыт - выставляю новый лимит-ордер на сохраненную цель {slot.sell_price_set:.6g}", "WARN"
)
if not place_limit_sell(exchange, slot, state):
state.log(f"[Слот {slot.index}] Не удалось переставить лимит-ордер после рестарта -> экстренная продажа", "ERR")
panic_sell_slot(exchange, slot, state, prefix="🚨 PANIC")
if restored_n:
state.log(
f"♻️ Персистентность: восстановлено {restored_n} слот(ов) из сохраненного состояния "
f"(сохранено {saved.get('saved_at', '?')})", "OK"
)
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:
state.log(
"📝 PAPER TRADING: РЕАЛЬНЫЕ цены с боевого Binance, ВИРТУАЛЬНЫЕ деньги. Реальные ордера создаваться не будут.", "WARN"
)
try:
if state.paper_trading:
exchange = build_exchange("", "", paper_trading=True)
else:
exchange = build_exchange(state.api_key, state.api_secret, paper_trading=False, proxy_url=state.proxy_url)
exchange.load_markets()
state.log("Биржа подключена", "OK")
# Восстанавливаем слоты, сохраненные до возможного рестарта процесса, и сверяем
# их с реальным балансом на бирже (актуально в первую очередь для 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(
f"КРИТИЧНО: бюджет на слот ${per_slot:.2f} слишком мал (нужно от $1.05).", "ERR"
)
state.is_running = False
state.status = "🔴 Ошибка: мало бюджета на слот"
return
# Динамический лимит: разрешаем пары, где Binance допускает ордер <= бюджета на слот
# (с запасом 10%, чтобы не упираться в minNotional впритык из-за округления/комиссии)
dynamic_notional_cap = per_slot
allowed_symbols = get_allowed_symbols(exchange, max_notional=dynamic_notional_cap)
state.allowed_symbols_count = len(allowed_symbols)
state.last_symbols_refresh_at = time.time()
state.log(
f"Разрешенных ликвидных пар (minNotional <= ${dynamic_notional_cap:.2f}, бюджет/слот ${per_slot:.2f}): {len(allowed_symbols)}",
"INFO"
)
if not allowed_symbols:
state.log("КРИТИЧНО: нет пар с подходящим minNotional при текущем бюджете на слот", "ERR")
state.is_running = False
state.status = "🔴 Ошибка: нет пар"
return
except Exception as e:
state.log(f"Ошибка подключения к бирже: {e}", "ERR")
state.is_running = False
state.status = "🔴 Ошибка подключения"
return
state.last_full_screen_at = 0.0
while state.is_running:
try:
# Авто-масштабирование слотов - работает только в Live,
# само себя троттлит по времени внутри (раз в час)
maybe_autoscale_slots(exchange, state)
# Раз в час пересчитываем список разрешенных пар под АКТУАЛЬНЫЙ бюджет на слот -
# если депозит вырос (в т.ч. через авто-масштабирование выше), автоматически откроется больше монет
if time.time() - state.last_symbols_refresh_at >= SYMBOLS_REFRESH_INTERVAL_SEC:
try:
new_per_slot = state.budget_per_slot()
new_cap = new_per_slot
new_allowed = get_allowed_symbols(exchange, max_notional=new_cap)
if new_allowed:
old_count = len(allowed_symbols)
allowed_symbols = new_allowed
state.allowed_symbols_count = len(allowed_symbols)
if len(allowed_symbols) != old_count:
state.log(
f"🔄 Список пар обновлен: {old_count} -> {len(allowed_symbols)} "
f"(бюджет/слот ${new_per_slot:.2f})", "INFO"
)
except Exception as e:
state.log(f"Ошибка обновления списка разрешенных пар: {e}", "WARN")
state.last_symbols_refresh_at = time.time()
if state.strategy_engine == "grading":
# ── Режим "Градация": несколько крупных высоколиквидных монет, лесенка докупок на просадке ──
check_grading_opportunities(exchange, state)
process_grading_exits(exchange, state)
filled_total = sum(len(p["filled"]) for p in state.grading_positions.values())
state.status = f"📐 Градация: {len(state.grading_symbols)} монет, {filled_total} грейдов открыто"
time.sleep(5)
continue
# ── Режим "Портфель микро-слотов" (по умолчанию) ──
for slot in state.slots:
with state.slot_lock:
process_occupied_slot(exchange, slot, state)
# Пакетное наполнение пустых слотов за один общий проход скринера
empty_slots = [s for s in state.slots if s.is_empty()]
if empty_slots:
now = time.time()
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)
occupied_n = sum(1 for s in state.slots if not s.is_empty())
if occupied_n == state.num_slots:
state.status = f"🟢 Портфель полон ({occupied_n}/{state.num_slots})"
elif occupied_n == 0:
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})"
except Exception as e:
state.log(f"Ошибка в главном цикле: {e}", "ERR")
time.sleep(5)
state.log("Торговый цикл остановлен", "INFO")
state.status = "⏹ Остановлен"
def maybe_cold_start_resume(state: BotState):
"""
Холодный старт: если сервер (контейнер HF Spaces) только что перезапустился/проснулся,
а в сохраненном состоянии стоит is_running=True - автоматически поднимает фоновый
trading_loop БЕЗ клика пользователя по кнопке "Запустить портфель".
Срабатывает ровно один раз за жизнь процесса благодаря флагу на самом BotState
(не модульной переменной - см. пояснение в BotState.__init__).
"""
with state._cold_start_lock:
if state._cold_start_attempted:
return
state._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 ИНТЕРФЕЙС
# ─────────────────────────────────────────────
def render_ui():
st.set_page_config(
page_title="GVP Micro Scalper — Portfolio",
page_icon="⚡",
layout="wide",
)
st.markdown("""
""", 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")
env_badge = "📝 PAPER TRADING (симулятор на живом рынке)" if state.paper_trading else "🔴 LIVE (реальные деньги)"
st.markdown(
f'{env_badge} | Status: {state.status}
',
unsafe_allow_html=True,
)
col1, col2, col3, col4, col5 = st.columns(5)
with col1:
st.metric("💰 Прибыль сессии", f"${state.total_profit:.4f}")
with col2:
st.metric("🔄 Ротаций", state.trades_count)
with col3:
occupied_n = sum(1 for s in state.slots if not s.is_empty())
st.metric("📦 Слотов занято", f"{occupied_n}/{state.num_slots}")
with col4:
st.metric("💵 Бюджет/слот", f"${state.budget_per_slot():.2f}")
with col5:
st.metric("🌐 Ликвидных пар", state.allowed_symbols_count or "—")
st.divider()
col_left, col_right = st.columns([1, 2])
with col_left:
st.subheader("⚙️ Настройки портфеля")
trading_mode = st.radio(
"Режим торговли",
options=["📝 Paper trading (симулятор)", "🔴 Live (реальные деньги)"],
index=0 if state.paper_trading else 1,
disabled=state.is_running,
help="Paper trading: реальные цены с боевого Binance, виртуальные деньги, ключи НЕ нужны вообще. Live: настоящие сделки, настоящие деньги."
)
paper_trading = trading_mode.startswith("📝")
if paper_trading:
st.success(
"📝 Paper trading активен. Бот будет смотреть РЕАЛЬНЫЕ цены живого рынка и вести виртуальный учёт сделок — ни один реальный ордер создан не будет. API-ключи не требуются для этого режима.",
icon="📝",
)
else:
st.error(
"🔴 LIVE режим. Бот будет создавать РЕАЛЬНЫЕ ордера на твои РЕАЛЬНЫЕ деньги. Используй только после полноценной проверки в paper trading.",
icon="🔴",
)
with st.expander("🔑 API Ключи", expanded=not state.is_running and not paper_trading):
if paper_trading:
st.caption("Paper trading не требует ключей — бот использует только публичные данные рынка (data-api.binance.vision, не блокируется гео-фильтром).")
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")
st.divider()
proxy_url = st.text_input(
"🌐 Прокси для обхода гео-блокировки (опционально)",
value=state.proxy_url, type="password", key="inp_proxy",
placeholder="http://user:pass@host:port",
help=(
"Приватные эндпоинты Binance (ордера, баланс) блокируют запросы с IP из США - "
"именно там обычно физически находятся бесплатные HF Spaces. Укажи здесь прокси/VPS/туннель, "
"геолоцированный в разрешенной Binance стране (в идеале - совпадающей с твоим KYC, "
"например Казахстан), чтобы избежать и блокировки, и compliance-флагов на аккаунте. "
"Оставь пустым, если бот уже работает из разрешенного региона."
),
)
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)",
min_value=3.0, max_value=1000.0, value=state.total_budget, step=1.0,
help="Делится поровну между всеми слотами."
)
num_slots = st.slider(
"Количество параллельных слотов",
min_value=1, max_value=MAX_SLOTS, value=state.num_slots,
help=f"Сколько монет держим одновременно. Каждой нужно >= $1.05 при выбранном бюджете.",
disabled=state.is_running,
)
strategy_mode = st.selectbox(
"Режим скальпинга (Адаптивные фильтры)",
options=["🛡️ Консервативный (Особо точный)", "⚖️ Умеренный (Сбалансированный)", "🔥 Агрессивный (Частые сделки)"],
index=1 if "Умеренный" in state.strategy_mode else (0 if "Консервативный" in state.strategy_mode else 2),
help="🛡️ Консервативный: более жесткие фильтры входа, покупает только на глубоких просадках при сильной перепроданности. 🔥 Агрессивный: более мягкие фильтры, совершает входы гораздо чаще."
)
use_dynamic_tp = st.checkbox(
"Использовать динамический Тейк-Профит",
value=state.use_dynamic_tp,
help="Если включено, бот будет автоматически рассчитывать цель прибыли под каждую монету на основе её суточной волатильности (для более высокой прибыли на волатильных парах)."
)
max_correlation = st.slider(
"Порог диверсификации: макс. корреляция доходностей между слотами",
min_value=0.10, max_value=1.00, value=state.max_correlation, step=0.05,
help=(
"Бот сравнивает недавние доходности (1м) кандидата с уже открытыми позициями и с другими "
"отбираемыми кандидатами. Если корреляция выше этого порога - монета пропускается в пользу "
"менее коррелируемой (если таких не осталось - слот все равно заполняется лучшим по score, "
"чтобы не простаивать). Меньше значение = строже диверсификация, слоты более независимы друг от друга."
),
)
use_depth_check = st.checkbox(
"Проверять глубину стакана перед покупкой (защита от проскальзывания)",
value=state.use_depth_check,
help=(
"Перед market buy бот считает средневзвешенную цену исполнения по реальному стакану (asks) "
"и сравнивает с лучшим ask. Если расхождение больше порога ниже - покупка отменяется "
"(значит стакан слишком тонкий для нашего объема на этой монете)."
),
)
max_slippage_pct = st.slider(
"Макс. допустимое проскальзывание при покупке (%)",
min_value=0.05, max_value=3.0, value=state.max_slippage_pct, step=0.05,
disabled=not use_depth_check,
help="Если средняя цена исполнения нашего объема хуже лучшего ask больше чем на этот %, покупка отменяется.",
)
st.divider()
st.markdown("**⚙️ Движок стратегии**")
strategy_engine = st.radio(
"Выбери режим торговли (работает только один из двух одновременно)",
options=["portfolio", "grading"],
index=0 if state.strategy_engine == "portfolio" else 1,
format_func=lambda x: "🔹 Портфель микро-слотов (текущий)" if x == "portfolio" else "📐 Градация крупных монет (лесенка на просадке)",
help=(
"Портфель микро-слотов - то, что уже работает: N независимых слотов по $4-20, ротация, диверсификация.\n\n"
"Градация - альтернативный режим: несколько КРУПНЫХ высоколиквидных монет (BTC/ETH/BNB/...), "
"докупка лесенкой по мере просадки от суточного хая (глубже просадка -> крупнее объем докупки), "
"выход всей накопленной позицией разом при восстановлении цены к хаю."
),
)
grading_symbols = state.grading_symbols
grading_budget = state.grading_budget
if strategy_engine == "grading":
grading_symbols = st.multiselect(
"Монеты для градации (высоколиквидные)",
options=["BTC/USDT", "ETH/USDT", "BNB/USDT", "SOL/USDT", "XRP/USDT", "DOGE/USDT", "ADA/USDT", "TON/USDT"],
default=state.grading_symbols,
)
grading_budget = st.number_input(
"Бюджет на режим градации (USDT, отдельно от портфеля слотов)",
min_value=0.0, value=max(state.grading_budget, 20.0), step=10.0,
)
st.caption(
f"Уровни просадки для докупки: {', '.join(f'{l}%' for l in GRADING_DROP_LEVELS_PCT)} от суточного хая. "
f"Выход - при восстановлении в пределах {GRADING_RECOVERY_EXIT_PCT}% от хая."
)
st.divider()
st.markdown("**📈 Авто-масштабирование слотов по депозиту** (только Live)")
auto_scale_slots = st.checkbox(
"Включить авто-масштабирование",
value=state.auto_scale_slots,
disabled=paper_trading,
help=(
"Раз в час проверяет реальный баланс USDT на бирже и, если депозит дорос до следующего порога, "
"автоматически добавляет слоты (никогда не уменьшает - открытые позиции не трогает). "
"Пороги: " + ", ".join(f"${t}→{n} слотов" for t, n in SLOT_SCALING_TABLE)
),
)
target_profit = st.number_input(
"Базовая чистая прибыль на ПОЗИЦИЮ (USDT)",
min_value=0.01, max_value=2.0, value=state.target_profit, step=0.01,
disabled=use_dynamic_tp,
help="Используется только если выключен динамический Тейк-Профит."
)
use_bnb = st.checkbox(
"У меня включена скидка 'Use BNB for fees' на Binance",
value=state.use_bnb_discount,
help="Снижает комиссию с 0.1% до 0.075%. ВАЖНО: должно совпадать с реальной настройкой в Binance, иначе цена продажи будет рассчитана неточно и часть прибыли уходит в погрешность."
)
use_timeout = st.checkbox(
"Включить принудительный выход по жесткому тайм-ауту",
value=state.use_timeout,
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="Применяется только при включенном жестком фланге выше."
)
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
if per_slot_preview < 1.05:
st.error(f"⚠️ Бюджет на слот ${per_slot_preview:.2f} < $1.05 минимума! Увеличь бюджет или уменьши слоты.")
else:
growth = (target_profit + per_slot_preview * active_fee * 2) / per_slot_preview * 100
fee_label = "0.075% (BNB)" if use_bnb else "0.1% (стандарт)"
st.info(f"📐 На слот: **${per_slot_preview:.2f}** | Требуемый рост: **{growth:.2f}%** | Комиссия: **{fee_label}**")
if not state.is_running:
if st.button("▶️ Запустить портфель", use_container_width=True, type="primary"):
if not paper_trading and (not api_key or not api_secret):
st.error("Введи API Key и Secret!")
elif per_slot_preview < 1.05:
st.error("Бюджет на слот недостаточен")
else:
state.paper_trading = paper_trading
state.api_key = api_key
state.api_secret = api_secret
state.total_budget = total_budget
state.target_profit = target_profit
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.max_correlation = max_correlation
state.proxy_url = proxy_url
state.use_depth_check = use_depth_check
state.max_slippage_pct = max_slippage_pct
state.strategy_engine = strategy_engine
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 = []
state.total_profit = 0.0
state.trades_count = 0
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()
st.divider()
st.markdown("**🔄 Сброс для чистого теста стратегии**")
st.caption(
"Полностью обнуляет прибыль сессии, ротации, журнал сделок, лог и все слоты (включая "
"сохраненное состояние на диске/HF Dataset) — чтобы гонять новую версию стратегии с "
"нуля, не смешивая её результаты со старыми цифрами. Доступно только когда бот остановлен."
)
confirm_reset = st.checkbox(
"Понимаю: это необратимо сотрет статистику/слоты. Если есть открытые LIVE-позиции, "
"сначала закрою их Panic Sell — сброс их НЕ продаст на бирже, только забудет в боте.",
key="confirm_full_reset", # Убрали конфликтующий value=False
)
# Кнопка теперь всегда нажимается, защита находится внутри
if st.button("🔄 Сбросить всё и начать заново", use_container_width=True):
if state.is_running:
st.warning("⚠️ Бот должен быть остановлен для сброса (нажмите 'Остановить портфель').")
elif not confirm_reset:
st.warning("⚠️ Сначала подтвердите сброс, поставив галочку выше.")
else:
has_open = any(not s.is_empty() for s in state.slots)
if has_open and not state.paper_trading:
st.error(
"Есть открытые LIVE-позиции в слотах. Сначала закрой их через Panic Sell — "
"иначе бот забудет про реальные монеты у тебя на балансе биржи."
)
else:
state.slots = [Slot(index=i) for i in range(state.num_slots)]
state.paper_trades = []
state.logs = []
state.total_profit = 0.0
state.trades_count = 0
state.market_snapshot = []
state.grading_positions = {}
state.last_full_screen_at = 0.0
state.last_autoscale_check_at = 0.0
state.recent_network_errors = []
state.status = "⏹ Остановлен (после сброса)"
state.save_persisted_state()
# Снимаем галочку автоматически после успешного сброса
st.session_state["confirm_full_reset"] = False
st.success("Готово — статистика и слоты обнулены (в т.ч. в сохраненном состоянии). Можно запускать новый тест.")
st.rerun()
st.divider()
st.markdown("**📐 Формула цены продажи (на слот)**")
st.code(
"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"
)
st.divider()
st.markdown("**📡 Снимок последнего скрина рынка**")
if state.market_snapshot:
df = pd.DataFrame(state.market_snapshot)
df = df[["symbol", "score", "drawdown", "rsi", "volatility_24h", "volume", "spread"]].copy()
df["score"] = df["score"].round(1)
df["rsi"] = df["rsi"].round(1)
df["drawdown"] = (df["drawdown"] * 100).round(2).astype(str) + "%"
df["volatility_24h"] = (df["volatility_24h"] * 100).round(2).astype(str) + "%"
df["spread"] = (df["spread"] * 100).round(3).astype(str) + "%"
df["volume"] = df["volume"].round(0).astype(int)
st.dataframe(df, use_container_width=True, hide_index=True)
else:
st.caption("Скрин еще не выполнялся.")
with col_right:
st.subheader(f"📦 Слоты портфеля ({state.num_slots})")
for slot in state.slots:
css_class = "slot-card occupied" if not slot.is_empty() else "slot-card empty"
if slot.is_empty():
st.markdown(f"""
Слот {slot.index} — 🔍 Пусто, ищем монету...
""", unsafe_allow_html=True)
else:
elapsed_min = 0
if slot.order_placed_at:
elapsed_min = int((datetime.now(timezone.utc) - slot.order_placed_at).total_seconds() / 60)
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 " (безлимит)"
# Незафиксированный 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''
f'{pnl_sign}{unrealized_usd:.4f} USDT ({pnl_sign}{unrealized_cents:.1f}¢)'
)
else:
pnl_html = '— (цена еще не проверялась)'
st.markdown(f"""
Слот {slot.index}: {slot.symbol}
Куплено: {slot.bought_qty:.4f} по {slot.buy_price_avg:.6g} ({slot.usdt_spent:.4f} USDT)
Цель продажи: {slot.sell_price_set:.6g} (цель profit: {slot.target_profit_set:.4f} USDT)
Незафиксированный P&L: {pnl_html}
Статус: {slot.status} | Удержание: {elapsed_min} мин{timeout_str}
""", unsafe_allow_html=True)
if state.is_running:
if st.button(f"🚨 Panic Sell слот {slot.index}", key=f"panic_{slot.index}"):
try:
if state.paper_trading:
exchange = build_exchange("", "", paper_trading=True)
else:
exchange = build_exchange(state.api_key, state.api_secret, paper_trading=False, proxy_url=state.proxy_url)
# Лочим тот же slot_lock, что и фоновый trading_loop -
# исключает гонку потоков, если бот в этот момент как раз обрабатывает этот слот
with state.slot_lock:
closed_ok = panic_sell_slot(exchange, slot, state, prefix="🚨 PANIC")
if closed_ok:
st.warning(f"Слот {slot.index} закрыт принудительно!")
else:
st.error(
f"Слот {slot.index}: продажа не удалась - позиция НЕ очищена из учета бота "
f"(проверь баланс на бирже и попробуй Panic Sell еще раз, см. лог)."
)
st.rerun()
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)")
if state.paper_trades:
trades_df = pd.DataFrame(state.paper_trades)
cols = ["time", "symbol", "action", "slot", "price", "qty", "usdt_value", "profit"]
for c in cols:
if c not in trades_df.columns:
trades_df[c] = None
trades_df = trades_df[cols].copy()
trades_df["action"] = trades_df["action"].str.upper()
trades_df["price"] = trades_df["price"].round(6)
trades_df["qty"] = trades_df["qty"].round(6)
trades_df["usdt_value"] = trades_df["usdt_value"].round(4)
trades_df["profit"] = trades_df["profit"].apply(lambda x: f"${x:.4f}" if (pd.notnull(x) and x is not None) else "—")
st.dataframe(trades_df, use_container_width=True, hide_index=True)
else:
st.caption("Сделок еще не зафиксировано.")
# ── График сделок (Candlestick + отметки входов/выходов) ──
st.divider()
st.subheader("📈 График сделок")
traded_symbols = sorted({t["symbol"] for t in state.paper_trades}) if state.paper_trades else []
if traded_symbols:
col_sel, col_btn = st.columns([3, 1])
with col_sel:
chart_symbol = st.selectbox("Тикер для графика", options=traded_symbols, key="chart_symbol_select")
with col_btn:
st.write("")
st.write("")
build_chart = st.button("📊 Построить график", use_container_width=True)
if build_chart:
try:
if state.paper_trading:
chart_exchange = build_exchange("", "", paper_trading=True)
else:
chart_exchange = build_exchange(state.api_key, state.api_secret, paper_trading=False, proxy_url=state.proxy_url)
ohlcv = chart_exchange.fetch_ohlcv(chart_symbol, timeframe="1m", limit=150)
if not ohlcv:
st.warning(f"Не удалось получить свечи для {chart_symbol}")
else:
df_chart = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
df_chart["dt"] = pd.to_datetime(df_chart["ts"], unit="ms", utc=True)
fig = go.Figure(data=[go.Candlestick(
x=df_chart["dt"],
open=df_chart["open"],
high=df_chart["high"],
low=df_chart["low"],
close=df_chart["close"],
name=chart_symbol,
increasing_line_color="#26a69a",
decreasing_line_color="#ef5350",
)])
# Фильтруем сделки бота ровно по выбранному символу
symbol_trades = [t for t in state.paper_trades if t["symbol"] == chart_symbol]
buy_x, buy_y, buy_txt = [], [], []
sell_x, sell_y, sell_txt = [], [], []
for t in symbol_trades:
raw_time = t.get("time", "")
try:
# Формат "YYYY-MM-DD HH:MM:SS UTC" -> парсим, убрав суффикс UTC
t_dt = pd.to_datetime(
raw_time.replace(" UTC", ""),
format="%Y-%m-%d %H:%M:%S",
utc=True,
)
except Exception:
continue
action = (t.get("action") or "").upper()
price = t.get("price")
if price is None:
continue
if action == "BUY":
buy_x.append(t_dt)
buy_y.append(price)
buy_txt.append(f"BUY slot={t.get('slot')}
{price:.6g}")
elif any(k in action for k in ("SELL", "ROTATION", "PANIC", "TIMEOUT")):
sell_x.append(t_dt)
sell_y.append(price)
profit = t.get("profit")
p_str = f"{profit:.4f}" if profit is not None else "—"
sell_txt.append(f"{action} slot={t.get('slot')}
{price:.6g} | profit={p_str}")
if buy_x:
fig.add_trace(go.Scatter(
x=buy_x, y=buy_y, mode="markers", name="BUY",
marker=dict(symbol="triangle-up", size=14, color="#00e676",
line=dict(width=1, color="#00381f")),
text=buy_txt, hoverinfo="text+x",
))
if sell_x:
fig.add_trace(go.Scatter(
x=sell_x, y=sell_y, mode="markers", name="SELL / ROTATE / PANIC",
marker=dict(symbol="triangle-down", size=14, color="#ff1744",
line=dict(width=1, color="#4a0000")),
text=sell_txt, hoverinfo="text+x",
))
fig.update_layout(
template="plotly_dark",
title=f"{chart_symbol} — 1m свечи с отметками сделок бота",
xaxis_title="Время (UTC)",
yaxis_title="Цена",
xaxis_rangeslider_visible=False,
height=550,
margin=dict(l=10, r=10, t=50, b=10),
paper_bgcolor="#0d1117",
plot_bgcolor="#0d1117",
legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
)
st.plotly_chart(fig, use_container_width=True)
except Exception as e:
st.error(f"Ошибка построения графика: {e}")
else:
st.caption("Пока нет сделок для отображения графика — дождись первой покупки бота.")
st.divider()
st.subheader("📋 Лог торговли")
log_lines = list(state.logs)
if log_lines:
log_text = "\n".join(reversed(log_lines))
st.markdown(f'{log_text}
', unsafe_allow_html=True)
else:
st.info("Лог пуст. Запусти бота для начала работы.")
if state.is_running:
if st.button("🔄 Обновить"):
st.rerun()
st.divider()
st.markdown("""
⚠️ Торговля криптовалютой сопряжена с высоким риском потери капитала.
Этот бот предназначен для образовательных целей. Используй только те средства,
которые готов потерять полностью. Прошлые результаты не гарантируют будущих.
""", unsafe_allow_html=True)
if __name__ == "__main__":
render_ui()