Update 2_trading_bot_logic.py

2_trading_bot_logic.py

@@ -6,82 +6,78 @@ from binance.exceptions import BinanceAPIException
 from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, pipeline
 from peft import PeftModel
 import torch
-import config as cfg # Импортируем наш конфиг
-# from dotenv import load_dotenv # Если используете .env
-# import os
-
-# load_dotenv() # Загрузка переменных из .env, если используется
-# API_KEY = os.getenv("BINANCE_API_KEY")
-# API_SECRET = os.getenv("BINANCE_API_SECRET")
-# Если не .env, то берем из config.py (НЕБЕЗОПАСНО ДЛЯ ПРОДА)
-API_KEY = cfg.BINANCE_API_KEY
-API_SECRET = cfg.BINANCE_API_SECRET
+import config as cfg
 
 # --- Инициализация клиента Binance ---
 if cfg.USE_TESTNET:
-    client = Client(API_KEY, API_SECRET, testnet=True) # Для тестовой сети
+    client = Client(cfg.BINANCE_API_KEY, cfg.BINANCE_API_SECRET, testnet=True)
     print("Используется ТЕСТОВАЯ СЕТЬ Binance.")
 else:
-    client = Client(API_KEY, API_SECRET)
+    client = Client(cfg.BINANCE_API_KEY, cfg.BINANCE_API_SECRET)
     print("ВНИМАНИЕ: Используется РЕАЛЬНАЯ СЕТЬ Binance!")
 
-
 # --- Загрузка обученной модели (адаптера) ---
-# Для инференса можно также использовать квантизацию
-bnb_config_inf = BitsAndBytesConfig(
-    load_in_4bit=True,
-    bnb_4bit_quant_type="nf4",
-    bnb_4bit_compute_dtype=torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16,
-)
-
-base_model = AutoModelForCausalLM.from_pretrained(
-    cfg.BASE_MODEL_NAME,
-    quantization_config=bnb_config_inf,
-    torch_dtype=torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16,
-    device_map="auto",
-    trust_remote_code=True
-)
-tokenizer = AutoTokenizer.from_pretrained(cfg.BASE_MODEL_NAME, trust_remote_code=True)
-tokenizer.pad_token = tokenizer.eos_token
+model = None
+tokenizer = None
+text_generator = None
 
 try:
-    model = PeftModel.from_pretrained(base_model, cfg.FINETUNED_ADAPTER_PATH)
-    model.eval() # Перевод в режим инференса
-    print(f"Адаптер {cfg.FINETUNED_ADAPTER_PATH} успешно загружен.")
-except Exception as e:
-    print(f"Ошибка загрузки адаптера модели из {cfg.FINETUNED_ADAPTER_PATH}: {e}")
-    print("Убедитесь, что модель была обучена и адаптер сохранен.")
-    model = None # Чтобы последующий код не упал сразу
-
-
-# Или, если вы слили модель:
-# model = AutoModelForCausalLM.from_pretrained(cfg.MERGED_MODEL_PATH, device_map="auto", torch_dtype=torch.bfloat16)
-# tokenizer = AutoTokenizer.from_pretrained(cfg.MERGED_MODEL_PATH)
-# model.eval()
-
-# Создаем pipeline для удобства, если модель и токенизатор загружены
-if model and tokenizer:
-    text_generator = pipeline(
-        "text-generation",
-        model=model,
-        tokenizer=tokenizer,
-        device_map="auto" # или model.device
+    bnb_config_inf = BitsAndBytesConfig(
+        load_in_4bit=True,
+        bnb_4bit_quant_type="nf4",
+        bnb_4bit_compute_dtype=torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16,
     )
-else:
-    text_generator = None
+    base_model_for_inf = AutoModelForCausalLM.from_pretrained(
+        cfg.BASE_MODEL_NAME,
+        quantization_config=bnb_config_inf,
+        torch_dtype=torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16,
+        device_map="auto",
+        trust_remote_code=True
+    )
+    tokenizer = AutoTokenizer.from_pretrained(cfg.BASE_MODEL_NAME, trust_remote_code=True)
+    tokenizer.pad_token = tokenizer.eos_token
 
+    model = PeftModel.from_pretrained(base_model_for_inf, cfg.FINETUNED_ADAPTER_PATH)
+    model.eval()
+    print(f"Адаптер {cfg.FINETUNED_ADAPTER_PATH} успешно загружен.")
+
+    text_generator = pipeline("text-generation", model=model, tokenizer=tokenizer, device_map="auto")
+except Exception as e:
+    print(f"Ошибка загрузки модели или адаптера: {e}")
+    print("Убедитесь, что модель была обучена и адаптер сохранен в FINETUNED_ADAPTER_PATH.")
+
+
+def get_binance_klines_df(symbol, interval_str, limit):
+    """Получает klines и преобразует в pandas DataFrame с правильными типами."""
+    # Преобразование строки интервала в константу Binance Client
+    interval_map = {
+        '1m': Client.KLINE_INTERVAL_1MINUTE, '3m': Client.KLINE_INTERVAL_3MINUTE,
+        '5m': Client.KLINE_INTERVAL_5MINUTE, '15m': Client.KLINE_INTERVAL_15MINUTE,
+        '30m': Client.KLINE_INTERVAL_30MINUTE, '1h': Client.KLINE_INTERVAL_1HOUR,
+        '2h': Client.KLINE_INTERVAL_2HOUR, '4h': Client.KLINE_INTERVAL_4HOUR,
+        '6h': Client.KLINE_INTERVAL_6HOUR, '8h': Client.KLINE_INTERVAL_8HOUR,
+        '12h': Client.KLINE_INTERVAL_12HOUR, '1d': Client.KLINE_INTERVAL_1DAY,
+        '3d': Client.KLINE_INTERVAL_3DAY, '1w': Client.KLINE_INTERVAL_1WEEK,
+        '1M': Client.KLINE_INTERVAL_1MONTH
+    }
+    if interval_str not in interval_map:
+        raise ValueError(f"Неподдерживаемый интервал: {interval_str}")
+    interval = interval_map[interval_str]
 
-def get_market_data_binance(symbol, interval, limit):
-    """Получает исторические данные (свечи) с Binance."""
     try:
         klines = client.get_klines(symbol=symbol, interval=interval, limit=limit)
-        df = pd.DataFrame(klines, columns=['Timestamp', 'Open', 'High', 'Low', 'Close', 'Volume', 
-                                           'CloseTime', 'QuoteAssetVolume', 'NumberTrades', 
-                                           'TakerBuyBaseAssetVolume', 'TakerBuyQuoteAssetVolume', 'Ignore'])
-        df['Timestamp'] = pd.to_datetime(df['Timestamp'], unit='ms')
-        df.set_index('Timestamp', inplace=True)
-        for col in ['Open', 'High', 'Low', 'Close', 'Volume']: # И другие числовые, если нужны
-            df[col] = pd.to_numeric(df[col])
+        df = pd.DataFrame(klines, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume', 
+                                           'close_time', 'quote_asset_volume', 'number_trades', 
+                                           'taker_buy_base_asset_volume', 'taker_buy_quote_asset_volume', 'ignore'])
+        df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
+        df.set_index('timestamp', inplace=True) # Устанавливаем индекс для pandas_ta
+        
+        # Преобразование колонок в числовой тип
+        cols_to_numeric = ['open', 'high', 'low', 'close', 'volume', 'quote_asset_volume', 
+                           'taker_buy_base_asset_volume', 'taker_buy_quote_asset_volume']
+        for col in cols_to_numeric:
+            df[col] = pd.to_numeric(df[col], errors='coerce')
+        df.rename(columns={'timestamp':'date'}, inplace=False) # Для pandas_ta нужны стандартные имена
         return df
     except BinanceAPIException as e:
         print(f"Ошибка API Binance при получении данных: {e}")
@@ -89,160 +85,162 @@ def get_market_data_binance(symbol, interval, limit):
         print(f"Другая ошибка при получении данных: {e}")
     return pd.DataFrame()
 
+def calculate_live_indicators_from_df(df):
+    """Рассчитывает индикаторы для DataFrame с последними данными Binance."""
+    if df.empty: return df
+    
+    # Убедимся, что колонки OHLCV называются так, как ожидает pandas_ta
+    # (get_binance_klines_df уже должен это делать)
+    
+    # RSI
+    df.ta.rsi(length=7, append=True, col_names=('rsi_7',))
+    df.ta.rsi(length=14, append=True, col_names=('rsi_14',))
+    # CCI
+    df.ta.cci(length=7, append=True, col_names=('cci_7',))
+    df.ta.cci(length=14, append=True, col_names=('cci_14',))
+    # SMA
+    df.ta.sma(length=50, append=True, col_names=('sma_50',))
+    df.ta.sma(length=100, append=True, col_names=('sma_100',))
+    # EMA
+    df.ta.ema(length=50, append=True, col_names=('ema_50',))
+    df.ta.ema(length=100, append=True, col_names=('ema_100',))
+    # MACD - возвращает macd, macd_histogram, macd_signal
+    macd_df = df.ta.macd()
+    if macd_df is not None and not macd_df.empty:
+        df['macd'] = macd_df.iloc[:,0] # Берем первую колонку (обычно это и есть линия MACD)
+    else:
+        df['macd'] = pd.NA
 
-def calculate_live_indicators(df):
-    """Рассчитывает индикаторы для DataFrame с последними данными."""
-    # Используйте те же индикаторы и параметры, что и при обучении
-    df.ta.rsi(length=14, append=True, col_names=('RSI',))
-    df.ta.macd(append=True, col_names=('MACD', 'MACD_hist', 'MACD_signal'))
-    df.ta.sma(length=20, append=True, col_names=('SMA_20',))
-    df.ta.sma(length=50, append=True, col_names=('SMA_50',))
-    df.ta.bbands(length=20, append=True, col_names=('BB_lower', 'BB_mid', 'BB_upper', 'BB_bandwidth', 'BB_percent'))
-    # df.dropna(inplace=True) # Обычно последняя строка может иметь NaN, если индикаторы требуют больше данных
+    # Bollinger Bands - возвращает BBL, BBM, BBU, BBB, BBP
+    bbands_df = df.ta.bbands(length=20) # Стандартная длина 20 для BB
+    if bbands_df is not None and not bbands_df.empty:
+         # Предполагаем, что 'bollinger' в вашем CSV - это средняя линия
+        df['bollinger'] = bbands_df.iloc[:,1] # BBM_20_2.0 (средняя линия)
+    else:
+        df['bollinger'] = pd.NA
+
+    # TrueRange - pandas_ta имеет atr, который использует TrueRange внутри.
+    # Если нужен сам TrueRange, можно рассчитать его отдельно или взять из ATR расчета.
+    # df.ta.true_range(append=True, col_names=('TrueRange',)) # Если pandas_ta такой имеет
+    # Вручную True Range:
+    df['prev_close'] = df['close'].shift(1)
+    df['hl'] = df['high'] - df['low']
+    df['h_pc'] = abs(df['high'] - df['prev_close'])
+    df['l_pc'] = abs(df['low'] - df['prev_close'])
+    df['TrueRange'] = df[['hl', 'h_pc', 'l_pc']].max(axis=1)
+    df.drop(columns=['prev_close', 'hl', 'h_pc', 'l_pc'], inplace=True)
+
+
+    # ATR
+    df.ta.atr(length=7, append=True, col_names=('atr_7',))
+    df.ta.atr(length=14, append=True, col_names=('atr_14',))
+    
     return df
 
 
-def format_live_data_for_llm(current_data_row, indicators_to_use):
-    """Форматирует живые данные для LLM, так же, как в 0_prepare_data.py."""
-    prompt = f"Текущая цена закрытия BTC/USDT: {current_data_row['Close']:.2f}. "
-    desc_parts = []
-    for indicator in indicators_to_use:
-        if indicator in current_data_row and pd.notna(current_data_row[indicator]):
-            desc_parts.append(f"{indicator}: {current_data_row[indicator]:.2f}")
+def format_live_data_for_llm(current_data_row):
+    """Форматирует живые данные для LLM, используя ВСЕ колонки, как в обучении."""
+    # Собираем все колонки, которые были в обучающем датасете (кроме next_day_close)
+    # На основе вашего CSV:
+    expected_cols_for_prompt = [
+        'open', 'high', 'low', 'close', 'volume', 'rsi_7', 'rsi_14', 
+        'cci_7', 'cci_14', 'sma_50', 'ema_50', 'sma_100', 'ema_100', 
+        'macd', 'bollinger', 'TrueRange', 'atr_7', 'atr_14'
+    ]
+    
+    prompt_parts = []
+    # Базовая информация OHLCV первой
+    for col in ['open', 'high', 'low', 'close', 'volume']:
+        if col in current_data_row and pd.notna(current_data_row[col]):
+            value = current_data_row[col]
+            prompt_parts.append(f"{col}: {value:.2f}" if col != 'volume' else f"{col}: {value:.0f}")
+    
+    base_prompt = ", ".join(prompt_parts) + "."
+
+    # Технические индикаторы
+    indicator_descs = []
+    for col in expected_cols_for_prompt:
+        if col not in ['open', 'high', 'low', 'close', 'volume'] and \
+           col in current_data_row and pd.notna(current_data_row[col]):
+            indicator_descs.append(f"{col.replace('_', ' ')}: {current_data_row[col]:.2f}")
     
-    if not desc_parts: return None
-    prompt += "Технические индикаторы: " + ", ".join(desc_parts) + "."
-    # prompt += " Какое действие предпринять (BUY, SELL, HOLD)?" # Этот вопрос будет частью [INST] промпта
+    if indicator_descs:
+        tech_prompt = "Technical indicators: " + ", ".join(indicator_descs) + "."
+        full_description = base_prompt + " " + tech_prompt
+    else:
+        full_description = base_prompt
+        
     # Полный промпт для модели (должен совпадать с форматом обучения)
-    full_prompt = f"<s>[INST] Анализ рынка BTC/USDT. {prompt} Какое действие предпринять: BUY, SELL, или HOLD? [/INST]"
-    return full_prompt
+    llm_prompt = f"<s>[INST] Анализ рынка BTC/USDT на основе следующих данных: {full_description} Какое торговое действие (BUY, SELL, или HOLD) следует предпринять? [/INST]"
+    return llm_prompt
 
 
 def get_llm_prediction(prompt_text):
-    """Получает предсказание от LLM."""
     if not text_generator:
         print("Генератор текста (LLM) не инициализирован.")
-        return "HOLD" # Безопасное значение по умолчанию
-
-    # Параметры генерации
-    # max_new_tokens должно быть маленьким, т.к. мы ожидаем одно слово: BUY, SELL, или HOLD
+        return "HOLD"
     try:
-        outputs = text_generator(
-            prompt_text,
-            max_new_tokens=5,  # Ожидаем короткий ответ
-            do_sample=False,   # Для более детерминированного ответа
-            pad_token_id=tokenizer.eos_token_id
-        )
-        # Ответ будет в outputs[0]['generated_text']
-        # Нужно извлечь сам сигнал из сгенерированного текста
+        outputs = text_generator(prompt_text, max_new_tokens=10, do_sample=False, pad_token_id=tokenizer.eos_token_id)
         full_response = outputs[0]['generated_text']
-        # Извлекаем то, что после [/INST]
         signal_text = full_response.split("[/INST]")[-1].strip().upper()
         
-        # Проверяем, является ли сигнал одним из ожидаемых
-        if signal_text.startswith("BUY"): return "BUY"
-        if signal_text.startswith("SELL"): return "SELL"
-        if signal_text.startswith("HOLD"): return "HOLD"
-
-        print(f"Нераспознанный сигнал от LLM: '{signal_text}' из ответа '{full_response}'. Возвращаем HOLD.")
-        return "HOLD"
+        if "BUY" in signal_text: return "BUY"
+        if "SELL" in signal_text: return "SELL"
+        return "HOLD" # По умолчанию HOLD, если нечеткий сигнал
     except Exception as e:
         print(f"Ошибка при генерации текста LLM: {e}")
         return "HOLD"
 
-def execute_trade(signal, symbol, quantity_usd):
-    """Исполняет сделку на Binance."""
+def execute_trade_logic(signal, symbol, quantity_usd):
+    """Очень упрощенная логика торговли (см. предыдущий ответ для деталей и предупреждений)."""
     if signal == "HOLD":
         print("Сигнал: HOLD. Нет действий.")
         return
 
-    # Получаем текущую цену для расчета количества актива
     try:
         ticker = client.get_symbol_ticker(symbol=symbol)
         current_price = float(ticker['price'])
-    except Exception as e:
-        print(f"Не удалось получить текущую цену для {symbol}: {e}")
-        return
-
-    if current_price == 0:
-        print(f"Текущая цена для {symbol} равна 0. Невозможно рассчитать количество.")
-        return
+        if current_price == 0: return
 
-    quantity_asset = quantity_usd / current_price
-    
-    # Binance требует определенной точности для количества и цены
-    # Получаем информацию о символе для форматирования
-    try:
+        quantity_asset_precise = quantity_usd / current_price
+        
+        # Получение информации о символе для форматирования количества
         info = client.get_symbol_info(symbol)
         step_size = 0.0
-        tick_size = 0.0
+        min_notional_val = 5.0 # Обычно около 5-10 USD для BTCUSDT
+        
         for f in info['filters']:
             if f['filterType'] == 'LOT_SIZE':
                 step_size = float(f['stepSize'])
-            if f['filterType'] == 'PRICE_FILTER':
-                tick_size = float(f['tickSize'])
-        
-        # Форматируем количество
+            if f['filterType'] == 'MIN_NOTIONAL':
+                min_notional_val = float(f['minNotional'])
+
         if step_size > 0:
-             quantity_asset = (quantity_asset // step_size) * step_size
-        # Убедимся, что количество не слишком маленькое (minNotional)
-        # Этот код упрощен, в реальности проверка minNotional сложнее
-        if quantity_asset * current_price < 10: # Примерный порог minNotional (для BTCUSDT около 5-10 USD)
-            print(f"Рассчитанное количество {quantity_asset} для {symbol} слишком мало (меньше порога minNotional). Сделка не выполняется.")
-            return
+            quantity_asset = (quantity_asset_precise // step_size) * step_size
+        else: # Если step_size не найден или 0, пробуем округление (менее надежно)
+            # Для BTC обычно 5-6 знаков после запятой для количества
+            if symbol == "BTCUSDT": quantity_asset = round(quantity_asset_precise, 5)
+            else: quantity_asset = round(quantity_asset_precise, 3)
 
-    except Exception as e:
-        print(f"Ошибка получения информации о символе {symbol} для форматирования ордера: {e}")
-        # Продолжаем без точного форматирования, может вызвать ошибку при создании ордера
-    
-    if quantity_asset == 0:
-        print("Рассчитанное количество актива равно 0. Сделка не выполняется.")
-        return
 
-    order_type = Client.ORDER_TYPE_MARKET # Рыночный ордер
-    print(f"Попытка исполнить {signal} ордер для {symbol}, количество: {quantity_asset:.8f} (на сумму ~{quantity_usd}$)")
+        if quantity_asset == 0:
+            print(f"Рассчитанное количество актива {quantity_asset_precise:.8f} после округления стало 0. Сделка не выполняется.")
+            return
+        if quantity_asset * current_price < min_notional_val:
+            print(f"Стоимость ордера {quantity_asset * current_price:.2f} USD меньше минимальной ({min_notional_val} USD). Сделка не выполняется.")
+            return
 
-    # ВАЖНО: УПРАВЛЕНИЕ ПОЗИЦИЯМИ
-    # Этот пример очень наивен: он просто покупает или продает.
-    # В реальной системе нужно отслеживать открытые позиции,
-    # решать, когда закрывать существующую позицию перед открытием новой и т.д.
-    # Например, если уже есть LONG позиция, а сигнал SELL, то нужно сначала продать (закрыть LONG),
-    # а потом, возможно, открыть SHORT (если это фьючерсы) или просто продать и ждать.
-    # Для спота: если есть BTC и сигнал SELL -> продаем BTC. Если нет BTC и сигнал BUY -> покупаем.
+        print(f"Попытка исполнить {signal} ордер для {symbol}, количество: {quantity_asset} (~{quantity_usd}$)")
 
-    try:
         if signal == "BUY":
-            # Проверяем баланс USDT
-            usdt_balance = float(client.get_asset_balance(asset='USDT')['free'])
-            if cfg.USE_TESTNET: # В тестнете балансы обычно большие, для реала эта проверка важна
-                usdt_balance = 100000 # Предположим большой баланс в тестнете
-            
-            if usdt_balance < quantity_usd:
-                print(f"Недостаточно USDT для покупки. Доступно: {usdt_balance}, нужно: {quantity_usd}")
-                return
-            
-            print(f"Размещение MARKET BUY ордера на {quantity_asset:.8f} {symbol.replace('USDT','')}...")
-            order = client.order_market_buy(symbol=symbol, quantity=round(quantity_asset, 5)) # Округление для BTC
+            # Тут должна быть проверка баланса USDT
+            print(f"Размещение MARKET BUY ордера на {quantity_asset} {symbol.replace('USDT','')}...")
+            order = client.order_market_buy(symbol=symbol, quantity=quantity_asset)
             print("BUY ордер размещен:", order)
-
         elif signal == "SELL":
-            # Проверяем баланс BTC (или другого базового актива)
-            base_asset = symbol.replace("USDT", "")
-            asset_balance_data = client.get_asset_balance(asset=base_asset)
-            if asset_balance_data:
-                asset_balance = float(asset_balance_data['free'])
-            else:
-                asset_balance = 0.0
-            
-            if asset_balance < quantity_asset:
-                print(f"Недостаточно {base_asset} для продажи. Доступно: {asset_balance}, нужно: {quantity_asset}")
-                # Можно продать все, что есть, если это часть стратегии
-                # quantity_asset = asset_balance 
-                # if quantity_asset == 0: return
-                return
-
-            print(f"Размещение MARKET SELL ордера на {quantity_asset:.8f} {symbol.replace('USDT','')}...")
-            order = client.order_market_sell(symbol=symbol, quantity=round(quantity_asset, 5)) # Округление для BTC
+            # Тут должна быть проверка баланса базового актива (напр. BTC)
+            print(f"Размещение MARKET SELL ордера на {quantity_asset} {symbol.replace('USDT','')}...")
+            order = client.order_market_sell(symbol=symbol, quantity=quantity_asset)
             print("SELL ордер размещен:", order)
 
     except BinanceAPIException as e:
@@ -256,52 +254,60 @@ def trading_loop():
         print("Модель не загружена. Торговый цикл не может быть запущен.")
         return
 
-    indicators_to_use_live = ['RSI', 'MACD', 'MACD_signal', 'SMA_50', 'SMA_200', 'Upper_BB', 'Lower_BB', 'Close', 'Volume']
+    # Определяем интервал и время ожидания
+    kline_interval_str = cfg.KLINE_INTERVAL_TO_TRADE
+    sleep_duration_seconds = 0
+    if 'm' in kline_interval_str:
+        sleep_duration_seconds = int(kline_interval_str.replace('m', '')) * 60
+    elif 'h' in kline_interval_str:
+        sleep_duration_seconds = int(kline_interval_str.replace('h', '')) * 3600
+    elif 'd' in kline_interval_str:
+        sleep_duration_seconds = int(kline_interval_str.replace('d', '')) * 86400
+    else: # По умолчанию 1 час, если н�� распознано
+        sleep_duration_seconds = 3600
+        print(f"Не удалось определить время сна для интервала {kline_interval_str}, используется {sleep_duration_seconds} сек.")
+
 
     while True:
         print(f"\n--- {time.ctime()} ---")
         # 1. Получение свежих данных
-        # Интервал должен соответствовать тому, на котором обучались. 
-        # Если обучались на дневных, а тут минутные - будет плохо.
-        # Для примера возьмем часовые свечи (Client.KLINE_INTERVAL_1HOUR)
-        # cfg.LOOKBACK_PERIODS должно быть достаточным для расчета всех индикаторов.
-        df_live = get_market_data_binance(cfg.TRADING_PAIR, Client.KLINE_INTERVAL_1HOUR, cfg.LOOKBACK_PERIODS + 5)
+        df_live = get_binance_klines_df(cfg.TRADING_PAIR, kline_interval_str, cfg.LOOKBACK_PERIODS_LIVE)
         
-        if df_live.empty or len(df_live) < 20: # Минимум для некоторых индикаторов
-            print("Недостаточно данных для анализа. Пропускаем цикл.")
-            time.sleep(60) # Ждем минуту
+        if df_live.empty or len(df_live) < 100: # Нужно достаточно данных для SMA100/EMA100 и ATR14
+            print(f"Недостаточно данных для анализа ({len(df_live)} строк). Пропускаем цикл.")
+            time.sleep(60)
             continue
 
         # 2. Расчет индикаторов
-        df_live = calculate_live_indicators(df_live.copy())
+        df_with_indicators = calculate_live_indicators_from_df(df_live.copy())
         
-        # Берем последнюю ПОЛНУЮ свечу для анализа (предпоследнюю строку, т.к. последняя может быть не закрыта)
-        # Или последнюю, если уверены, что get_klines возвращает только закрытые свечи для `limit`
-        # Для простоты возьмем последнюю доступную строку с рассчитанными индикаторами
-        current_market_state_row = df_live.iloc[-1] # Последняя строка с данными
-        
-        # Проверяем, есть ли NaN в ключевых индикаторах на последней строке
-        if current_market_state_row[indicators_to_use_live].isnull().any():
-            print("Последняя строка содержит NaN в индикаторах после расчета. Используем предпоследнюю, если есть.")
-            if len(df_live) > 1:
-                current_market_state_row = df_live.iloc[-2]
-                if current_market_state_row[indicators_to_use_live].isnull().any():
-                    print("Предпоследняя строка также содержит NaN. Пропускаем цикл.")
-                    time.sleep(60)
-                    continue
-            else:
-                print("Недостаточно строк для анализа после расчета индикаторов. Пропускаем цикл.")
-                time.sleep(60)
-                continue
-        
-        # 3. Форматирование для LLM
-        llm_prompt = format_live_data_for_llm(current_market_state_row, indicators_to_use_live)
+        # Берем последнюю ПОЛНУЮ свечу для анализа
+        # get_klines обычно возвращает последнюю свечу как частично сформированную, если limit > 1
+        # Для анализа лучше брать предпоследнюю, если это так.
+        # Или, если уверены, что последняя закрыта (например, если limit=1 и время свечи прошло)
+        # Для простоты, если используем lookback > 1, берем предпоследнюю.
+        if len(df_with_indicators) < 2:
+            print("Недостаточно строк после расчета индикаторов. Пропускаем.")
+            time.sleep(sleep_duration_seconds)
+            continue
         
-        if not llm_prompt:
-            print("Не удалось сформировать промпт для LLM. Пропускаем цикл.")
-            time.sleep(60)
+        current_market_state_row = df_with_indicators.iloc[-2] # Предпоследняя строка, более вероятно закрытая свеча
+
+        # Проверка на NaN в нужных колонках для current_market_state_row
+        # Список колонок, которые должны быть в промпте (из format_live_data_for_llm)
+        required_cols_for_prompt = [
+            'open', 'high', 'low', 'close', 'volume', 'rsi_7', 'rsi_14', 
+            'cci_7', 'cci_14', 'sma_50', 'ema_50', 'sma_100', 'ema_100', 
+            'macd', 'bollinger', 'TrueRange', 'atr_7', 'atr_14'
+        ]
+        if current_market_state_row[required_cols_for_prompt].isnull().any():
+            print("В данных для анализа (предпоследняя свеча) есть NaN значения в ключевых индикаторах. Пропускаем цикл.")
+            print(current_market_state_row[current_market_state_row[required_cols_for_prompt].isnull()])
+            time.sleep(sleep_duration_seconds)
             continue
             
+        # 3. Форматирование для LLM
+        llm_prompt = format_live_data_for_llm(current_market_state_row)
         print("Промпт для LLM:", llm_prompt)
 
         # 4. Получение предсказания от LLM
@@ -309,24 +315,20 @@ def trading_loop():
         print(f"Предсказанный сигнал: {predicted_signal}")
 
         # 5. Исполнение сделки (С ОСТОРОЖНОСТЬЮ!)
-        # ВАЖНО: Здесь должна быть серьезная логика управления рисками, проверки баланса и т.д.
         if not cfg.USE_TESTNET:
-             print_danger = input("ВЫ УВЕРЕНЫ, ЧТО ХОТИТЕ ТОРГОВАТЬ НА РЕАЛЬНОМ СЧЕТЕ? (yes/NO):")
-             if print_danger.lower() != "yes":
-                 print("Торговля на реальном счете отменена пользователем.")
-                 return # Выход из цикла и программы
+             user_confirm = input("ВЫ УВЕРЕНЫ, ЧТО ХОТИТЕ ТОРГОВАТЬ НА РЕАЛЬНОМ СЧЕТЕ? (yes/NO):")
+             if user_confirm.lower() != "yes":
+                 print("Торговля на реальном счете отменена.")
+                 return 
 
-        execute_trade(predicted_signal, cfg.TRADING_PAIR, cfg.TRADE_AMOUNT_USD)
+        execute_trade_logic(predicted_signal, cfg.TRADING_PAIR, cfg.TRADE_AMOUNT_USD)
         
-        # 6. Пауза перед следующим циклом
-        # Пауза должна соответствовать интервалу свечей, чтобы не анализировать те же данные много раз
-        # Если часовые свечи, то ждать около часа.
-        print("Ожидание следующего цикла (1 час)...")
-        time.sleep(3600) # 1 час
+        print(f"Ожидание следующего цикла ({sleep_duration_seconds // 60} минут)...")
+        time.sleep(sleep_duration_seconds)
 
 if __name__ == "__main__":
-    # Перед запуском убедитесь, что у вас есть обученный адаптер модели!
     if model and text_generator:
         trading_loop()
     else:
-        print("Модель не была корректно загружена. Запустите скрипт обучения 1_finetune_mixtral.py")
+        print("Модель не была корректно загружена. Запустите скрипт обучения (1_finetune_mixtral.py) "
+              "или проверьте путь к адаптеру в config.py (FINETUNED_ADAPTER_PATH).")