Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

сейчас тебе скину скрипт его надо подробно проанализировать и я скажу что нужно…

  1. User

    сейчас тебе скину скрипт его надо подробно проанализировать и я скажу что нужно поправить # bot.py

    import logging import aiohttp import pandas as pd import numpy as np import mplfinance as mpf from datetime import datetime, timedelta, timezone import telegram from telegram import InputMediaPhoto import asyncio import config from io import BytesIO from ta.trend import MACD, SMAIndicator, EMAIndicator, IchimokuIndicator from ta.momentum import RSIIndicator, StochasticOscillator from ta.volatility import BollingerBands, AverageTrueRange import os import glob from PIL import Image, version as PILLOW_VERSION from packaging import version from telegram.error import TelegramError, RetryAfter, TimedOut from concurrent.futures import ThreadPoolExecutor from matplotlib import pyplot as plt

    Настройка логирования

    logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s', handlers=[ logging.FileHandler("bot.log"), logging.StreamHandler() ] )

    Проверка версии Pillow и логирование

    try: pillow_version = version.parse(PILLOW_VERSION) if pillow_version < version.parse("10.0.0"): logging.warning(f"Используется устаревшая версия Pillow ({PILLOW_VERSION}). Рекомендуется обновиться до версии 10.0.0 или выше.") else: logging.info(f"Используется Pillow версии {PILLOW_VERSION}.") except Exception as e: logging.error(f"Не удалось определить версию Pillow: {e}")

    MAX_TG_MESSAGE_LENGTH = 4000 # Немного меньше, чем лимит Telegram MEDIA_GROUP_LIMIT_PER_SECOND = 20 # Настройте по необходимости

    Директория для сохранения графиков

    GRAPHS_DIR = 'graphs'

    Создание директории для графиков, если она не существует

    if not os.path.exists(GRAPHS_DIR): os.makedirs(GRAPHS_DIR)

    Функция для очистки предыдущих графиков

    def clean_previous_graphs(): try: files = glob.glob(os.path.join(GRAPHS_DIR, '*_72h.png')) for file in files: os.remove(file) logging.info(f"Удалено {len(files)} предыдущих графиков.") except Exception as e: logging.error(f"Ошибка при удалении предыдущих графиков: {e}")

    Асинхронная функция для получения списка всех фьючерсных пар USDT на Binance

    async def get_future_symbols(session): try: logging.info("Запрос списка фьючерсных пар USDT от Binance.") url = 'https://fapi.binance.com/fapi/v1/exchangeInfo' async with session.get(url) as response: response.raise_for_status() data = await response.json() symbols = [s['symbol'] for s in data['symbols'] if s['quoteAsset'] == 'USDT' and s['contractType'] == 'PERPETUAL'] logging.info(f"Найдено {len(symbols)} фьючерсных пар USDT.") return symbols except aiohttp.ClientError as e: logging.error(f"Ошибка при запросе списка символов: {e}") raise except Exception as e: logging.error(f"Неизвестная ошибка при обработке списка символов: {e}") raise

    Асинхронная функция для получения исторических данных от Binance Futures

    async def get_historical_klines(session, symbol, interval, hours): try: logging.info(f"Запрос данных для {symbol} с интервалом {interval} за последние {hours} часов.") end_time = datetime.now(timezone.utc) start_time = end_time - timedelta(hours=hours) start_timestamp = int(start_time.timestamp() * 1000) end_timestamp = int(end_time.timestamp() * 1000) url = 'https://fapi.binance.com/fapi/v1/klines' params = { 'symbol': symbol, 'interval': interval, 'startTime': start_timestamp, 'endTime': end_timestamp, 'limit': 1000 # Максимальное количество данных } async with session.get(url, params=params) as response: response.raise_for_status() data = await response.json() if not data: logging.warning(f"Нет данных для символа {symbol}.") return None df = pd.DataFrame(data, columns=[ 'Open time', 'Open', 'High', 'Low', 'Close', 'Volume', 'Close time', 'Quote asset volume', 'Number of trades', 'Taker buy base asset volume', 'Taker buy quote asset volume', 'Ignore' ]) df['Open time'] = pd.to_datetime(df['Open time'], unit='ms') df['Close time'] = pd.to_datetime(df['Close time'], unit='ms') df[['Open', 'High', 'Low', 'Close', 'Volume']] = df[['Open', 'High', 'Low', 'Close', 'Volume']].astype(float) df.sort_values('Open time', inplace=True) # Убедитесь, что данные отсортированы по времени logging.info(f"Данные успешно получены для {symbol} (строк: {len(df)}).") return df[['Open time', 'Open', 'High', 'Low', 'Close', 'Volume']] except aiohttp.ClientError as e: logging.error(f"Ошибка при запросе данных для {symbol}: {e}") return None except Exception as e: logging.error(f"Неизвестная ошибка при обработке данных для {symbol}: {e}") return None

    Функция для вычисления технических индикаторов

    def compute_indicators(df): try: logging.info("Вычисление технических индикаторов.")

        # RSI
        rsi = RSIIndicator(close=df['Close'], window=14)
        df['RSI'] = rsi.rsi()
    
        # MACD
        macd = MACD(close=df['Close'])
        df['MACD'] = macd.macd()
        df['MACD_Signal'] = macd.macd_signal()
        df['MACD_Diff'] = macd.macd_diff()
    
        # Скользящие средние (SMA50 и EMA20)
        sma50 = SMAIndicator(close=df['Close'], window=50)
        df['SMA50'] = sma50.sma_indicator()
    
        ema20 = EMAIndicator(close=df['Close'], window=20)
        df['EMA20'] = ema20.ema_indicator()
    
        # Полосы Боллинджера
        bb = BollingerBands(close=df['Close'], window=20, window_dev=2)
        df['BB_High'] = bb.bollinger_hband()
        df['BB_Low'] = bb.bollinger_lband()
    
        # Стохастический осциллятор
        stochastic = StochasticOscillator(high=df['High'], low=df['Low'], close=df['Close'], window=14, smooth_window=3)
        df['Stoch_%K'] = stochastic.stoch()
        df['Stoch_%D'] = stochastic.stoch_signal()
    
        # Ichimoku Cloud
        ichimoku = IchimokuIndicator(high=df['High'], low=df['Low'], window1=9, window2=26, window3=52)
        df['Ichimoku_A'] = ichimoku.ichimoku_a()
        df['Ichimoku_B'] = ichimoku.ichimoku_b()
    
        # ATR
        atr = AverageTrueRange(high=df['High'], low=df['Low'], close=df['Close'], window=14)
        df['ATR'] = atr.average_true_range()
    
        # VWAP
        df['VWAP'] = (df['Volume'] * (df['High'] + df['Low'] + df['Close']) / 3).cumsum() / df['Volume'].cumsum()
    
        logging.info("Технические индикаторы успешно вычислены.")
        return df
    except Exception as e:
        logging.error(f"Ошибка при вычислении индикаторов: {e}")
        raise
    

    Функция для определения направления на основе индикаторов и расчета точек входа и тейк-профита

    def analyze_indicators(df): try: logging.info("Анализ индикаторов для определения направления движения и расчета точек входа/тейк-профита.") latest = df.iloc[-1] previous = df.iloc[-2]

        signals = {
            'RSI': None,
            'MACD': None,
            'EMA20': None,
            'Bollinger Bands': None,
            'Stochastic Oscillator': None,
            'Ichimoku': None,
            'VWAP': None
        }
    
        # RSI
        if latest['RSI'] > 70:
            signals['RSI'] = 'Overbought'
        elif latest['RSI'] < 30:
            signals['RSI'] = 'Oversold'
    
        # MACD
        if latest['MACD'] > latest['MACD_Signal']:
            signals['MACD'] = 'Bullish Crossover'
        elif latest['MACD'] < latest['MACD_Signal']:
            signals['MACD'] = 'Bearish Crossover'
    
        # EMA20 vs. Close Price
        if latest['Close'] > latest['EMA20']:
            signals['EMA20'] = 'Price Above EMA20'
        else:
            signals['EMA20'] = 'Price Below EMA20'
    
        # Bollinger Bands
        if latest['Close'] > latest['BB_High']:
            signals['Bollinger Bands'] = 'Price Breaks Upper Band'
        elif latest['Close'] < latest['BB_Low']:
            signals['Bollinger Bands'] = 'Price Breaks Lower Band'
    
        # Stochastic Oscillator
        if latest['Stoch_%K'] > latest['Stoch_%D']:
            signals['Stochastic Oscillator'] = 'Bullish Signal'
        elif latest['Stoch_%K'] < latest['Stoch_%D']:
            signals['Stochastic Oscillator'] = 'Bearish Signal'
    
        # Ichimoku Cloud
        if latest['Close'] > latest['Ichimoku_A'] and latest['Close'] > latest['Ichimoku_B']:
            signals['Ichimoku'] = 'Above Cloud - Bullish'
        elif latest['Close'] < latest['Ichimoku_A'] and latest['Close'] < latest['Ichimoku_B']:
            signals['Ichimoku'] = 'Below Cloud - Bearish'
        else:
            signals['Ichimoku'] = 'Within Cloud - Neutral'
    
        # VWAP
        if latest['Close'] > latest['VWAP']:
            signals['VWAP'] = 'Price Above VWAP'
        else:
            signals['VWAP'] = 'Price Below VWAP'
    
        # Подсчет сигналов
        bullish_signals = [
            'Bullish Crossover', 'Price Above EMA20',
            'Price Breaks Upper Band', 'Bullish Signal',
            'Above Cloud - Bullish', 'Price Above VWAP'
        ]
        bearish_signals = [
            'Bearish Crossover', 'Price Below EMA20',
            'Price Breaks Lower Band', 'Bearish Signal',
            'Below Cloud - Bearish', 'Price Below VWAP'
        ]
    
        bullish = sum(1 for signal in signals.values() if signal in bullish_signals)
        bearish = sum(1 for signal in signals.values() if signal in bearish_signals)
    
        total = bullish + bearish
    
        if total == 0:
            direction = "Нейтрально"
            probability = "N/A"
        else:
            if bullish > bearish:
                direction = "Бычий тренд"
                probability = f"{(bullish / total) * 100:.2f}% вероятность"
            elif bearish > bullish:
                direction = "Медвежий тренд"
                probability = f"{(bearish / total) * 100:.2f}% вероятность"
            else:
                direction = "Нейтрально"
                probability = "50% вероятность"
    
        # Определение точки входа и тейк-профита на основе ATR
        entry_price = None
        take_profit = None
    
        if direction == "Бычий тренд":
            entry_price = latest['Close']
            take_profit = latest['Close'] + (latest['ATR'] * 2)  # Тейк-профит на 2 ATR выше
        elif direction == "Медвежий тренд":
            entry_price = latest['Close']
            take_profit = latest['Close'] - (latest['ATR'] * 2)  # Тейк-профит на 2 ATR ниже
    
        logging.info(f"Определенное направление: {direction} с вероятностью {probability}.")
        logging.info(f"Точка входа: {entry_price}, Тейк-профит: {take_profit}")
    
        return direction, probability, entry_price, take_profit
    
    except Exception as e:
        logging.error(f"Ошибка при анализе индикаторов: {e}")
        raise
    

    Функция для проверки достаточности объема торгов

    def is_volume_sufficient(df, threshold=1000): """ Проверяет, достаточен ли средний объем торгов за период.

    :param df: DataFrame с историческими данными.
    :param threshold: Минимальный средний объем торгов.
    :return: True если объем достаточен, иначе False.
    """
    average_volume = df['Volume'].mean()
    return average_volume >= threshold
    

    Функция для проверки достаточной вариации цен

    def has_sufficient_price_variation(df, min_variation=0.5): """ Проверяет, есть ли достаточная вариация цен.

    :param df: DataFrame с историческими данными.
    :param min_variation: Мин. вариация в процентах.
    :return: True если вариация достаточна, иначе False.
    """
    price_diff = df['High'].max() - df['Low'].min()
    if df['Low'].min() == 0:
        return False  # Избежать деления на ноль
    percentage_variation = (price_diff / df['Low'].min()) * 100
    return percentage_variation >= min_variation
    

    Функция для проверки, является ли изображение пустым (белым) на основе вариации

    def is_image_blank(image_path, variance_threshold=100.0): """ Проверяет, является ли изображение почти полностью белым или однотонным.

    :param image_path: Путь к изображению.
    :param variance_threshold: Порог вариативности. Меньше значения считает изображение пустым.
    :return: True если изображение пустое, иначе False.
    """
    try:
        with Image.open(image_path) as img:
            grayscale = img.convert('L')  # Преобразование в оттенки серого
            np_img = np.array(grayscale)
            variance = np.var(np_img)
            logging.debug(f"Variance for {image_path}: {variance}")
            return variance < variance_threshold
    except Exception as e:
        logging.error(f"Ошибка при проверке изображения {image_path}: {e}")
        return False
    

    Функция для сжатия изображений

    def compress_image(image_path, max_size=(800, 600), quality=70): """ Сжимает изображение и сохраняет его обратно.

    :param image_path: Путь к изображению.
    :param max_size: Максимальный размер изображения.
    :param quality: Качество сжатия.
    :return: True если сжатие прошло успешно и изображение не пустое, иначе False
    """
    try:
        with Image.open(image_path) as img:
            # Определяем метод ресэмплинга в зависимости от версии Pillow
            if version.parse(PILLOW_VERSION) >= version.parse("10.0.0"):
                resample_method = Image.Resampling.LANCZOS
            else:
                resample_method = Image.ANTIALIAS
    
            img.thumbnail(max_size, resample_method)
            img.save(image_path, optimize=True, quality=quality)
        logging.info(f"Изображение сжато и сохранено: {image_path}")
    
        # Проверка, не стало ли изображение пустым после сжатия
        if is_image_blank(image_path):
            logging.warning(f"Изображение {image_path} оказалось пустым после сжатия.")
            os.remove(image_path)
            return False
    
        return True
    except Exception as e:
        logging.error(f"Ошибка при сжатии изображения {image_path}: {e}")
        return False
    

    Функция для построения графика с отметками точек входа и тейк-профита

    def plot_candlestick(df, symbol, entry=None, take_profit=None): try: logging.info(f"Построение графика свечей для {symbol}.")

        if df.empty:
            logging.warning(f"Пустой DataFrame для {symbol}. Пропуск построения графика.")
            return None
    
        # Проверка наличия достаточного количества данных
        if df.shape[0] < 10:
            logging.warning(f"Недостаточно данных для построения графика {symbol}. (строк: {df.shape[0]})")
            return None
    
        # Проверка на вариацию цен
        if df['Close'].nunique() == 1:
            logging.warning(f"Все значения цены закрытия одинаковы для {symbol}. Пропуск построения графика.")
            return None
    
        logging.info(f"Данные для построения графика {symbol}:\n{df.tail()}")
    
        df = df.copy()
        df.set_index('Open time', inplace=True)
        mc = mpf.make_marketcolors(up='g', down='r', inherit=True)
        s = mpf.make_mpf_style(marketcolors=mc)
    
        # Используем matplotlib фигуру для добавления аннотаций
        fig, axlist = mpf.plot(
            df,
            type='candle',
            style=s,
            title=f'{symbol} - Последние 72 часа',
            ylabel='Цена (USDT)',
            volume=True,
            addplot=[],
            returnfig=True,
            figsize=(12, 8)
        )
    
        # Добавление линий входа и тейк-профита с аннотациями
        if entry and take_profit:
            ax = axlist[0]  # Основной график свечей
            ax.axhline(entry, linestyle='--', color='blue', linewidth=1)
            ax.axhline(take_profit, linestyle='--', color='orange', linewidth=1)
    
            # Добавление аннотаций рядом с последней свечой
            ax.annotate('Entry', xy=(df.index[-1], entry), xytext=(0, 10),
                        textcoords="offset points", arrowprops=dict(arrowstyle='->', color='blue'),
                        fontsize=8, color='blue', ha='right')
            ax.annotate('Take Profit', xy=(df.index[-1], take_profit), xytext=(0, -15),
                        textcoords="offset points", arrowprops=dict(arrowstyle='->', color='orange'),
                        fontsize=8, color='orange', ha='right')
    
        # Сохранение графика в буфер
        buffer = BytesIO()
        fig.savefig(buffer, format='png', dpi=100, bbox_inches='tight')
        plt.close(fig)
        buffer.seek(0)
        img = Image.open(buffer)
    
        # Проверка, не является ли изображение пустым
        grayscale = img.convert('L')  # Преобразование в оттенки серого
        np_img = np.array(grayscale)
        variance = np.var(np_img)
        logging.debug(f"Variance for {symbol}: {variance}")
        if variance < 100.0:  # Порог вариативности, подберите оптимальное значение
            logging.warning(f"График для {symbol} является пустым (variance={variance}). Пропуск.")
            return None
    
        # Сохранение изображения в файл
        filename = os.path.join(GRAPHS_DIR, f"{symbol}_72h.png")
        img.save(filename)
    
        # Сжатие изображения перед отправкой
        compression_success = compress_image(filename)
        if not compression_success:
            logging.warning(f"Изображение {filename} не прошло проверку на пустоту после сжатия.")
            return None
    
        logging.info(f"График сохранен как {filename}.")
        return filename
    except Exception as e:
        logging.error(f"Ошибка при построении графика для {symbol}: {e}")
        # Удаление файла в случае ошибки, если он был создан
        filename = os.path.join(GRAPHS_DIR, f"{symbol}_72h.png")
        if os.path.exists(filename):
            try:
                os.remove(filename)
                logging.info(f"Удален некорректный файл графика: {filename}")
            except Exception as remove_e:
                logging.error(f"Ошибка при удалении файла {filename}: {remove_e}")
        return None
    

    Функция для отправки отчета в Telegram с механизмом повторных попыток

    async def send_telegram_report(token, chat_id, bullish_symbols, bearish_symbols): bot = telegram.Bot(token=token) try: # Отправка списка монет с высокой вероятностью роста if bullish_symbols: message_growth = "📈 Список монет с высокой вероятностью роста:" logging.info("Отправка сообщения о монетах с высокой вероятностью роста.") await bot.send_message(chat_id=chat_id, text=message_growth, parse_mode='Markdown') logging.info(f"Отправка группы из {len(bullish_symbols)} графиков в Telegram для роста.") await send_media_group_with_retry(bot, chat_id, bullish_symbols) else: logging.info("Нет монет с высокой вероятностью роста для отправки.")

        # Отправка списка монет с высокой вероятностью падения
        if bearish_symbols:
            message_decline = "📉 **Список монет с высокой вероятностью падения:**"
            logging.info("Отправка сообщения о монетах с высокой вероятностью падения.")
            await bot.send_message(chat_id=chat_id, text=message_decline, parse_mode='Markdown')
            logging.info(f"Отправка группы из {len(bearish_symbols)} графиков в Telegram для падения.")
            await send_media_group_with_retry(bot, chat_id, bearish_symbols)
        else:
            logging.info("Нет монет с высокой вероятностью падения для отправки.")
    
        # Очистка директории графиков после отправки
        try:
            logging.info("Удаление отправленных графиков.")
            files = glob.glob(os.path.join(GRAPHS_DIR, '*_72h.png'))
            for file in files:
                os.remove(file)
            logging.info(f"Удалено {len(files)} графиков.")
        except Exception as e:
            logging.error(f"Ошибка при удалении графиков: {e}")
    
        logging.info("Отчет успешно отправлен в Telegram.")
    except Exception as e:
        logging.error(f"Ошибка при отправке отчета в Telegram: {e}")
    

    Функция для отправки медиа-группы с повторными попытками

    async def send_media_group_with_retry(bot, chat_id, symbols, retries=3, delay=5): """ Отправляет группу медиа-файлов с повторными попытками в случае ошибок.

    :param bot: Экземпляр бота telegram.Bot.
    :param chat_id: ID чата для отправки.
    :param symbols: Список символов с информацией (направление, вероятность, изображение, entry, take_profit).
    :param retries: Количество попыток повторной отправки.
    :param delay: Задержка между попытками.
    :return: None
    """
    media_group = []
    for symbol_info in symbols:
        symbol = symbol_info['symbol']
        direction = symbol_info['direction']
        probability = symbol_info['probability']
        image_path = symbol_info['image']
        entry = symbol_info.get('entry')
        take_profit = symbol_info.get('take_profit')
    
        if image_path is None:
            logging.warning(f"Нет данных изображения для {symbol}. Пропуск.")
            continue
    
        # Создание подписи для графика
        if direction == "Бычий тренд":
            emoji = "📈"
        elif direction == "Медвежий тренд":
            emoji = "📉"
        else:
            emoji = "🔍"  # Нейтральный тренд
    
        if entry and take_profit:
            caption = (
                f"{emoji} Монета: {symbol}\n"
                f"🔺 Направление: {direction}\n"
                f"🔢 Вероятность: {probability}\n"
                f"📍 Точка входа: {entry:.2f} USDT\n"
                f"🎯 Тейк-профит: {take_profit:.2f} USDT"
            )
        else:
            caption = (
                f"{emoji} Монета: {symbol}\n"
                f"🔺 Направление: {direction}\n"
                f"🔢 Вероятность: {probability}"
            )
    
        # Добавление изображения и подписи в медиа-группу
        try:
            with open(image_path, 'rb') as photo_file:
                media_group.append(InputMediaPhoto(photo_file, caption=caption))
        except Exception as e:
            logging.error(f"Ошибка при открытии изображения {image_path}: {e}")
            continue
    
        # Проверка, достигло ли количество медиа в группе лимита (10)
        if len(media_group) == 10:
            logging.info(f"Отправка группы из {len(media_group)} графиков в Telegram.")
            await send_media_group_with_retry_helper(bot, chat_id, media_group, retries, delay)
            media_group = []
            await asyncio.sleep(2)  # Увеличенная задержка между отправками
    
    # Отправка оставшихся графиков
    if media_group:
        logging.info(f"Отправка последней группы из {len(media_group)} графиков в Telegram.")
        await send_media_group_with_retry_helper(bot, chat_id, media_group, retries, delay)
        media_group = []
        await asyncio.sleep(2)  # Увеличенная задержка
    

    async def send_media_group_with_retry_helper(bot, chat_id, media_group, retries, delay): attempt = 0 while attempt < retries: try: await bot.send_media_group(chat_id=chat_id, media=media_group) logging.info(f"Группа медиа успешно отправлена (Попытка {attempt + 1}).") return except RetryAfter as e: logging.warning(f"Превышен лимит отправки. Попытка {attempt + 1} через {e.retry_after} секунд.") await asyncio.sleep(e.retry_after) except TimedOut: logging.warning(f"Таймаут при отправке группы медиа. Попытка {attempt + 1} через {delay} секунд.") await asyncio.sleep(delay) except TelegramError as e: logging.error(f"TelegramError при отправке группы медиа: {e}. Попытка {attempt + 1} через {delay} секунд.") await asyncio.sleep(delay) except Exception as e: logging.error(f"Неизвестная ошибка при отправке группы медиа: {e}. Попытка {attempt + 1} через {delay} секунд.") await asyncio.sleep(delay) attempt += 1

    logging.error("Не удалось отправить группу медиа после нескольких попыток.")
    

    Функция для обработки каждого символа

    async def process_symbol(session, symbol, semaphore, executor): async with semaphore: try: df = await get_historical_klines(session, symbol, '1h', 72) if df is None or len(df) < 50: # Убедиться, что данных достаточно для SMA50 logging.warning(f"Недостаточно данных для анализа {symbol}. Пропуск.") return None

            # Добавляем проверку объема торгов
            if not is_volume_sufficient(df):
                logging.info(f"Объем торгов для {symbol} ниже порога. Пропуск.")
                return None
    
            # Добавляем проверку вариации цен
            if not has_sufficient_price_variation(df):
                logging.info(f"Вариация цен для {symbol} ниже порога. Пропуск.")
                return None
    
            # Вычисление индикаторов (ограничено потоком для безопасности с Pandas и TA)
            loop = asyncio.get_event_loop()
            df = await loop.run_in_executor(executor, compute_indicators, df)
    
            # Анализ индикаторов
            direction, probability, entry_price, take_profit = await loop.run_in_executor(executor, analyze_indicators, df)
    
            # Проверка вероятности продолжения тренда
            if probability != "N/A":
                try:
                    prob_value = float(probability.split('%')[0])
                except ValueError:
                    logging.warning(f"Некорректное значение вероятности для {symbol}: {probability}. Пропуск.")
                    return None
    
                if prob_value >= 80.0:
                    logging.info(f"Монета {symbol} соответствует критерию (prob={probability}).")
    
                    # Построение графика с точками входа и тейк-профита (ограничено потоком для безопасности с Matplotlib и PIL)
                    image_path = await loop.run_in_executor(executor, plot_candlestick, df, symbol, entry_price, take_profit)
                    if image_path is None:
                        logging.warning(f"График для {symbol} не создан. Пропуск.")
                        return None
    
                    # Формирование информации для Telegram
                    return {
                        'symbol': symbol,
                        'direction': direction,
                        'probability': probability,
                        'image': image_path,
                        'entry': entry_price,
                        'take_profit': take_profit
                    }
    
            return None
    
        except Exception as e:
            logging.error(f"Ошибка при обработке символа {symbol}: {e}")
            return None
    

    Основная функция

    async def main(): try: # Очистка предыдущих графиков перед запуском clean_previous_graphs()

        # Создание сессии aiohttp
        connector = aiohttp.TCPConnector(limit=100)  # Настройте лимит под ваши нужды
        async with aiohttp.ClientSession(connector=connector) as session:
            symbols = await get_future_symbols(session)
            bullish_symbols = []
            bearish_symbols = []
    
            # Ограничение количества одновременных задач
            semaphore = asyncio.Semaphore(20)  # Настройте под ваши нужды
            executor = ThreadPoolExecutor(max_workers=10)  # Настройте под ваши нужды
    
            # Создание списка задач для обработки символов
            tasks = [
                process_symbol(session, symbol, semaphore, executor) for symbol in symbols
            ]
    
            # Параллельное выполнение задач
            results = await asyncio.gather(*tasks)
    
            # Обработка результатов
            for result in results:
                if result is None:
                    continue
                if result['direction'] == "Бычий тренд":
                    bullish_symbols.append(result)
                elif result['direction'] == "Медвежий тренд":
                    bearish_symbols.append(result)
    
            if bullish_symbols or bearish_symbols:
                # Отправка отчетных графиков в Telegram
                logging.info(f"Отправка отчета с {len(bullish_symbols)} монетами для роста и {len(bearish_symbols)} монетами для падения.")
                await send_telegram_report(config.TELEGRAM_TOKEN, config.CHAT_ID, bullish_symbols, bearish_symbols)
            else:
                logging.info("Нет монет, соответствующих критериям для отчета.")
    
            logging.info("Процесс завершен успешно.")
    except Exception as e:
        logging.error(f"Процесс завершился с ошибкой: {e}")
    

    if name == 'main': asyncio.run(main())

  2. Assistant

    Конечно, давайте подробно проанализируем предоставленный вами скрипт bot.py. Этот бот предназначен для анализа фьючерсных пар USDT на Binance, вычисления технических индикаторов, определения трендов и отправки соответствующих графиков и отчетов в Telegram. Ниже представлен подробный разбор каждого компонента скрипта, выявление потенциальных проблем и рекомендации по улучшению.

    1. Импортируемые библиотеки

    import logging
    import aiohttp
    import pandas as pd
    import numpy as np
    import mplfinance as mpf
    from datetime import datetime, timedelta, timezone
    import telegram
    from telegram import InputMediaPhoto
    import asyncio
    import config
    from io import BytesIO
    from ta.trend import MACD, SMAIndicator, EMAIndicator, IchimokuIndicator
    from ta.momentum import RSIIndicator, StochasticOscillator
    from ta.volatility import BollingerBands, AverageTrueRange
    import os
    import glob
    from PIL import Image, __version__ as PILLOW_VERSION
    from packaging import version
    from telegram.error import TelegramError, RetryAfter, TimedOut
    from concurrent.futures import ThreadPoolExecutor
    from matplotlib import pyplot as plt
    

    Анализ:

    • Используемые библиотеки: Скрипт использует широкий набор библиотек для работы с HTTP-запросами (aiohttp), обработки данных (pandas, numpy), вычисления технических индикаторов (ta), визуализации (mplfinance, matplotlib), работы с изображениями (PIL), а также для взаимодействия с Telegram API.
    • Асинхронность: Использование aiohttp и asyncio позволяет выполнять сетевые запросы и другие операции асинхронно, что повышает эффективность работы бота.
    • Параллельные вычисления: ThreadPoolExecutor используется для выполнения задач, связанных с pandas и ta, которые могут быть блокирующими.

    Рекомендации:

    • Убедитесь, что все библиотеки имеют актуальные версии и совместимы между собой.
    • Рассмотрите возможность использования aiogram вместо python-telegram-bot для более эффективной асинхронной работы с Telegram.

    2. Настройка логирования

    logging.basicConfig(
        level=logging.INFO,
        format='%(asctime)s - %(levelname)s - %(message)s',
        handlers=[
            logging.FileHandler("bot.log"),
            logging.StreamHandler()
        ]
    )
    

    Анализ:

    • Логирование настроено для записи как в файл bot.log, так и в консоль. Это полезно для отладки и мониторинга работы бота.
    • Уровень логирования установлен на INFO, что подходит для общей эксплуатации.

    Рекомендации:

    • Рассмотрите добавление ротации логов с помощью handlers вроде RotatingFileHandler, чтобы предотвратить чрезмерный рост файла логов.
    • Возможно, имеет смысл разделить логи на разные уровни (например, ERROR в отдельный файл) для упрощения анализа.

    3. Проверка версии Pillow

    try:
        pillow_version = version.parse(PILLOW_VERSION)
        if pillow_version < version.parse("10.0.0"):
            logging.warning(f"Используется устаревшая версия Pillow ({PILLOW_VERSION}). Рекомендуется обновиться до версии 10.0.0 или выше.")
        else:
            logging.info(f"Используется Pillow версии {PILLOW_VERSION}.")
    except Exception as e:
        logging.error(f"Не удалось определить версию Pillow: {e}")
    

    Анализ:

    • Проверяется версия библиотеки Pillow, что важно для поддержки определенных методов и функций.
    • Если версия ниже 10.0.0, выдается предупреждение.

    Рекомендации:

    • Возможно, следует автоматически обновлять библиотеку или блокировать запуск скрипта при несовместимой версии.

    4. Основные константы и настройки директорий

    MAX_TG_MESSAGE_LENGTH = 4000  # Немного меньше, чем лимит Telegram
    MEDIA_GROUP_LIMIT_PER_SECOND = 20  # Настройте по необходимости
    
    GRAPHS_DIR = 'graphs'
    
    if not os.path.exists(GRAPHS_DIR):
        os.makedirs(GRAPHS_DIR)
    

    Анализ:

    • MAX_TG_MESSAGE_LENGTH установлен на 4000 символов, что ниже предела Telegram (4096 символов). Это предотвращает ошибки при отправке сообщений.
    • Директория graphs создается при необходимости для хранения графиков.

    Рекомендации:

    • Рассмотрите использование переменных окружения или файла конфигурации для настройки этих параметров без необходимости изменения кода.
    • Добавьте проверку наличия достаточного места на диске перед созданием и сохранением графиков.

    5. Функции очистки и обработки графиков

    5.1 Очистка предыдущих графиков

    def clean_previous_graphs():
        try:
            files = glob.glob(os.path.join(GRAPHS_DIR, '*_72h.png'))
            for file in files:
                os.remove(file)
            logging.info(f"Удалено {len(files)} предыдущих графиков.")
        except Exception as e:
            logging.error(f"Ошибка при удалении предыдущих графиков: {e}")
    

    Анализ:

    • Функция удаляет все файлы графиков за последние 72 часа в директории graphs.

    Рекомендации:

    • Убедитесь, что 72 часа – это правильный промежуток для удаления, и что он соответствует логике работы скрипта.
    • Добавьте обработку потенциальных ошибок, например, если файл занят другим процессом.

    5.2 Проверка пустоты изображения

    def is_image_blank(image_path, variance_threshold=100.0):
        try:
            with Image.open(image_path) as img:
                grayscale = img.convert('L')  # Преобразование в оттенки серого
                np_img = np.array(grayscale)
                variance = np.var(np_img)
                logging.debug(f"Variance for {image_path}: {variance}")
                return variance < variance_threshold
        except Exception as e:
            logging.error(f"Ошибка при проверке изображения {image_path}: {e}")
            return False
    

    Анализ:

    • Проверяет, является ли изображение пустым или однотонным, основываясь на вариации пикселей.
    • Это важно для предотвращения отправки некорректных или пустых графиков.

    Рекомендации:

    • Подберите оптимальное значение variance_threshold, возможно, добавив возможность настройки через конфигурационный файл.
    • Рассмотрите возможность анализа других характеристик изображения для более точной проверки.

    5.3 Сжатие изображения

    def compress_image(image_path, max_size=(800, 600), quality=70):
        try:
            with Image.open(image_path) as img:
                # Определяем метод ресэмплинга в зависимости от версии Pillow
                if version.parse(PILLOW_VERSION) >= version.parse("10.0.0"):
                    resample_method = Image.Resampling.LANCZOS
                else:
                    resample_method = Image.ANTIALIAS
    
                img.thumbnail(max_size, resample_method)
                img.save(image_path, optimize=True, quality=quality)
            logging.info(f"Изображение сжато и сохранено: {image_path}")
    
            # Проверка, не стало ли изображение пустым после сжатия
            if is_image_blank(image_path):
                logging.warning(f"Изображение {image_path} оказалось пустым после сжатия.")
                os.remove(image_path)
                return False
    
            return True
        except Exception as e:
            logging.error(f"Ошибка при сжатии изображения {image_path}: {e}")
            return False
    

    Анализ:

    • Функция сжимает изображение до заданного размера и качества.
    • Проверяет, не стало ли изображение пустым после сжатия, и при необходимости удаляет его.

    Рекомендации:

    • Позволяйте настраивать параметры max_size и quality через конфигурационный файл.
    • Рассмотрите использование других методов сжатия или форматов изображений для лучшего баланса между качеством и размером.

    5.4 Построение графика свечей

    def plot_candlestick(df, symbol, entry=None, take_profit=None):
        try:
            logging.info(f"Построение графика свечей для {symbol}.")
    
            if df.empty:
                logging.warning(f"Пустой DataFrame для {symbol}. Пропуск построения графика.")
                return None
    
            # Проверка наличия достаточного количества данных
            if df.shape[0] < 10:
                logging.warning(f"Недостаточно данных для построения графика {symbol}. (строк: {df.shape[0]})")
                return None
    
            # Проверка на вариацию цен
            if df['Close'].nunique() == 1:
                logging.warning(f"Все значения цены закрытия одинаковы для {symbol}. Пропуск построения графика.")
                return None
    
            logging.info(f"Данные для построения графика {symbol}:\n{df.tail()}")
    
            df = df.copy()
            df.set_index('Open time', inplace=True)
            mc = mpf.make_marketcolors(up='g', down='r', inherit=True)
            s = mpf.make_mpf_style(marketcolors=mc)
    
            # Используем matplotlib фигуру для добавления аннотаций
            fig, axlist = mpf.plot(
                df,
                type='candle',
                style=s,
                title=f'{symbol} - Последние 72 часа',
                ylabel='Цена (USDT)',
                volume=True,
                addplot=[],
                returnfig=True,
                figsize=(12, 8)
            )
    
            # Добавление линий входа и тейк-профита с аннотациями
            if entry and take_profit:
                ax = axlist[0]  # Основной график свечей
                ax.axhline(entry, linestyle='--', color='blue', linewidth=1)
                ax.axhline(take_profit, linestyle='--', color='orange', linewidth=1)
    
                # Добавление аннотаций рядом с последней свечой
                ax.annotate('Entry', xy=(df.index[-1], entry), xytext=(0, 10),
                            textcoords="offset points", arrowprops=dict(arrowstyle='->', color='blue'),
                            fontsize=8, color='blue', ha='right')
                ax.annotate('Take Profit', xy=(df.index[-1], take_profit), xytext=(0, -15),
                            textcoords="offset points", arrowprops=dict(arrowstyle='->', color='orange'),
                            fontsize=8, color='orange', ha='right')
    
            # Сохранение графика в буфер
            buffer = BytesIO()
            fig.savefig(buffer, format='png', dpi=100, bbox_inches='tight')
            plt.close(fig)
            buffer.seek(0)
            img = Image.open(buffer)
    
            # Проверка, не является ли изображение пустым
            grayscale = img.convert('L')  # Преобразование в оттенки серого
            np_img = np.array(grayscale)
            variance = np.var(np_img)
            logging.debug(f"Variance for {symbol}: {variance}")
            if variance < 100.0:  # Порог вариативности, подберите оптимальное значение
                logging.warning(f"График для {symbol} является пустым (variance={variance}). Пропуск.")
                return None
    
            # Сохранение изображения в файл
            filename = os.path.join(GRAPHS_DIR, f"{symbol}_72h.png")
            img.save(filename)
    
            # Сжатие изображения перед отправкой
            compression_success = compress_image(filename)
            if not compression_success:
                logging.warning(f"Изображение {filename} не прошло проверку на пустоту после сжатия.")
                return None
    
            logging.info(f"График сохранен как {filename}.")
            return filename
        except Exception as e:
            logging.error(f"Ошибка при построении графика для {symbol}: {e}")
            # Удаление файла в случае ошибки, если он был создан
            filename = os.path.join(GRAPHS_DIR, f"{symbol}_72h.png")
            if os.path.exists(filename):
                try:
                    os.remove(filename)
                    logging.info(f"Удален некорректный файл графика: {filename}")
                except Exception as remove_e:
                    logging.error(f"Ошибка при удалении файла {filename}: {remove_e}")
            return None
    

    Анализ:

    • Функция строит график свечей для заданного символа, добавляет линии входа и тейк-профита, сохраняет изображение и сжимает его.
    • Проверки на достаточность данных и вариацию цен предотвращают создание неинформативных графиков.
    • Используется mplfinance для построения графиков и matplotlib для аннотаций.

    Рекомендации:

    • Рассмотрите возможность добавления больше технических индикаторов или аналитических элементов на график для повышения информативности.
    • Оптимизируйте параметры графика (цвета, стили линий) для лучшей визуальной привлекательности.
    • Возможно, стоит добавить водяные знаки или брендинг для графиков, если планируется их массовая отправка.

    6. Функции для получения данных с Binance

    6.1 Получение списка фьючерсных пар USDT

    async def get_future_symbols(session):
        try:
            logging.info("Запрос списка фьючерсных пар USDT от Binance.")
            url = 'https://fapi.binance.com/fapi/v1/exchangeInfo'
            async with session.get(url) as response:
                response.raise_for_status()
                data = await response.json()
                symbols = [s['symbol'] for s in data['symbols']
                           if s['quoteAsset'] == 'USDT' and s['contractType'] == 'PERPETUAL']
                logging.info(f"Найдено {len(symbols)} фьючерсных пар USDT.")
                return symbols
        except aiohttp.ClientError as e:
            logging.error(f"Ошибка при запросе списка символов: {e}")
            raise
        except Exception as e:
            logging.error(f"Неизвестная ошибка при обработке списка символов: {e}")
            raise
    

    Анализ:

    • Функция запрашивает информацию об обмене с Binance и фильтрует символы с quoteAsset равным USDT и contractType равным PERPETUAL.
    • Возвращает список символов, соответствующих критериям.

    Рекомендации:

    • Добавьте кэширование результата или проверку изменения списка символов, чтобы избежать избыточных запросов.
    • Обработайте возможные изменения API Binance, например, добавление новых контрактов.

    6.2 Получение исторических данных

    async def get_historical_klines(session, symbol, interval, hours):
        try:
            logging.info(f"Запрос данных для {symbol} с интервалом {interval} за последние {hours} часов.")
            end_time = datetime.now(timezone.utc)
            start_time = end_time - timedelta(hours=hours)
            start_timestamp = int(start_time.timestamp() * 1000)
            end_timestamp = int(end_time.timestamp() * 1000)
            url = 'https://fapi.binance.com/fapi/v1/klines'
            params = {
                'symbol': symbol,
                'interval': interval,
                'startTime': start_timestamp,
                'endTime': end_timestamp,
                'limit': 1000  # Максимальное количество данных
            }
            async with session.get(url, params=params) as response:
                response.raise_for_status()
                data = await response.json()
                if not data:
                    logging.warning(f"Нет данных для символа {symbol}.")
                    return None
                df = pd.DataFrame(data, columns=[
                    'Open time', 'Open', 'High', 'Low', 'Close', 'Volume',
                    'Close time', 'Quote asset volume', 'Number of trades',
                    'Taker buy base asset volume', 'Taker buy quote asset volume', 'Ignore'
                ])
                df['Open time'] = pd.to_datetime(df['Open time'], unit='ms')
                df['Close time'] = pd.to_datetime(df['Close time'], unit='ms')
                df[['Open', 'High', 'Low', 'Close', 'Volume']] = df[['Open', 'High', 'Low', 'Close', 'Volume']].astype(float)
                df.sort_values('Open time', inplace=True)  # Убедитесь, что данные отсортированы по времени
                logging.info(f"Данные успешно получены для {symbol} (строк: {len(df)}).")
                return df[['Open time', 'Open', 'High', 'Low', 'Close', 'Volume']]
        except aiohttp.ClientError as e:
            logging.error(f"Ошибка при запросе данных для {symbol}: {e}")
            return None
        except Exception as e:
            logging.error(f"Неизвестная ошибка при обработке данных для {symbol}: {e}")
            return None
    

    Анализ:

    • Функция получает исторические данные свечей (klines) для заданного символа, интервала и периода.
    • Преобразует полученные данные в pandas DataFrame с нужными колонками.

    Рекомендации:

    • Добавьте проверку на частичные данные или несоответствие ожидаемого количества записей.
    • Убедитесь, что Spotify API не изменил структуру ответа (response.json()), что может привести к ошибкам при парсинге.
    • Обработайте возможные ограничения по частоте запросов (rate limits).

    7. Функции для вычисления и анализа технических индикаторов

    7.1 Вычисление индикаторов

    def compute_indicators(df):
        try:
            logging.info("Вычисление технических индикаторов.")
    
            # RSI
            rsi = RSIIndicator(close=df['Close'], window=14)
            df['RSI'] = rsi.rsi()
    
            # MACD
            macd = MACD(close=df['Close'])
            df['MACD'] = macd.macd()
            df['MACD_Signal'] = macd.macd_signal()
            df['MACD_Diff'] = macd.macd_diff()
    
            # Скользящие средние (SMA50 и EMA20)
            sma50 = SMAIndicator(close=df['Close'], window=50)
            df['SMA50'] = sma50.sma_indicator()
    
            ema20 = EMAIndicator(close=df['Close'], window=20)
            df['EMA20'] = ema20.ema_indicator()
    
            # Полосы Боллинджера
            bb = BollingerBands(close=df['Close'], window=20, window_dev=2)
            df['BB_High'] = bb.bollinger_hband()
            df['BB_Low'] = bb.bollinger_lband()
    
            # Стохастический осциллятор
            stochastic = StochasticOscillator(high=df['High'], low=df['Low'], close=df['Close'], window=14, smooth_window=3)
            df['Stoch_%K'] = stochastic.stoch()
            df['Stoch_%D'] = stochastic.stoch_signal()
    
            # Ichimoku Cloud
            ichimoku = IchimokuIndicator(high=df['High'], low=df['Low'], window1=9, window2=26, window3=52)
            df['Ichimoku_A'] = ichimoku.ichimoku_a()
            df['Ichimoku_B'] = ichimoku.ichimoku_b()
    
            # ATR
            atr = AverageTrueRange(high=df['High'], low=df['Low'], close=df['Close'], window=14)
            df['ATR'] = atr.average_true_range()
    
            # VWAP
            df['VWAP'] = (df['Volume'] * (df['High'] + df['Low'] + df['Close']) / 3).cumsum() / df['Volume'].cumsum()
    
            logging.info("Технические индикаторы успешно вычислены.")
            return df
        except Exception as e:
            logging.error(f"Ошибка при вычислении индикаторов: {e}")
            raise
    

    Анализ:

    • Вычисляются несколько ключевых технических индикаторов, включая RSI, MACD, SMA, EMA, полосы Боллинджера, стохастический осциллятор, Ichimoku Cloud, ATR и VWAP.
    • Все индикаторы добавляются в DataFrame для последующего анализа.

    Рекомендации:

    • Убедитесь, что окна индикаторов соответствуют вашим стратегиям торговли. Возможно, стоит дать возможность настраивать параметры через конфигурационный файл.
    • Добавьте проверки на наличие достаточного количества данных перед вычислением долгосрочных индикаторов (например, SMA50 требует минимум 50 записей).
    • Рассмотрите возможность нормализации или стандартизации данных для улучшения стабильности вычислений.

    7.2 Анализ индикаторов

    def analyze_indicators(df):
        try:
            logging.info("Анализ индикаторов для определения направления движения и расчета точек входа/тейк-профита.")
            latest = df.iloc[-1]
            previous = df.iloc[-2]
    
            signals = {
                'RSI': None,
                'MACD': None,
                'EMA20': None,
                'Bollinger Bands': None,
                'Stochastic Oscillator': None,
                'Ichimoku': None,
                'VWAP': None
            }
    
            # RSI
            if latest['RSI'] > 70:
                signals['RSI'] = 'Overbought'
            elif latest['RSI'] < 30:
                signals['RSI'] = 'Oversold'
    
            # MACD
            if latest['MACD'] > latest['MACD_Signal']:
                signals['MACD'] = 'Bullish Crossover'
            elif latest['MACD'] < latest['MACD_Signal']:
                signals['MACD'] = 'Bearish Crossover'
    
            # EMA20 vs. Close Price
            if latest['Close'] > latest['EMA20']:
                signals['EMA20'] = 'Price Above EMA20'
            else:
                signals['EMA20'] = 'Price Below EMA20'
    
            # Bollinger Bands
            if latest['Close'] > latest['BB_High']:
                signals['Bollinger Bands'] = 'Price Breaks Upper Band'
            elif latest['Close'] < latest['BB_Low']:
                signals['Bollinger Bands'] = 'Price Breaks Lower Band'
    
            # Stochastic Oscillator
            if latest['Stoch_%K'] > latest['Stoch_%D']:
                signals['Stochastic Oscillator'] = 'Bullish Signal'
            elif latest['Stoch_%K'] < latest['Stoch_%D']:
                signals['Stochastic Oscillator'] = 'Bearish Signal'
    
            # Ichimoku Cloud
            if latest['Close'] > latest['Ichimoku_A'] and latest['Close'] > latest['Ichimoku_B']:
                signals['Ichimoku'] = 'Above Cloud - Bullish'
            elif latest['Close'] < latest['Ichimoku_A'] and latest['Close'] < latest['Ichimoku_B']:
                signals['Ichimoku'] = 'Below Cloud - Bearish'
            else:
                signals['Ichimoku'] = 'Within Cloud - Neutral'
    
            # VWAP
            if latest['Close'] > latest['VWAP']:
                signals['VWAP'] = 'Price Above VWAP'
            else:
                signals['VWAP'] = 'Price Below VWAP'
    
            # Подсчет сигналов
            bullish_signals = [
                'Bullish Crossover', 'Price Above EMA20',
                'Price Breaks Upper Band', 'Bullish Signal',
                'Above Cloud - Bullish', 'Price Above VWAP'
            ]
            bearish_signals = [
                'Bearish Crossover', 'Price Below EMA20',
                'Price Breaks Lower Band', 'Bearish Signal',
                'Below Cloud - Bearish', 'Price Below VWAP'
            ]
    
            bullish = sum(1 for signal in signals.values() if signal in bullish_signals)
            bearish = sum(1 for signal in signals.values() if signal in bearish_signals)
    
            total = bullish + bearish
    
            if total == 0:
                direction = "Нейтрально"
                probability = "N/A"
            else:
                if bullish > bearish:
                    direction = "Бычий тренд"
                    probability = f"{(bullish / total) * 100:.2f}% вероятность"
                elif bearish > bullish:
                    direction = "Медвежий тренд"
                    probability = f"{(bearish / total) * 100:.2f}% вероятность"
                else:
                    direction = "Нейтрально"
                    probability = "50% вероятность"
    
            # Определение точки входа и тейк-профита на основе ATR
            entry_price = None
            take_profit = None
    
            if direction == "Бычий тренд":
                entry_price = latest['Close']
                take_profit = latest['Close'] + (latest['ATR'] * 2)  # Тейк-профит на 2 ATR выше
            elif direction == "Медвежий тренд":
                entry_price = latest['Close']
                take_profit = latest['Close'] - (latest['ATR'] * 2)  # Тейк-профит на 2 ATR ниже
    
            logging.info(f"Определенное направление: {direction} с вероятностью {probability}.")
            logging.info(f"Точка входа: {entry_price}, Тейк-профит: {take_profit}")
    
            return direction, probability, entry_price, take_profit
    
        except Exception as e:
            logging.error(f"Ошибка при анализе индикаторов: {e}")
            raise
    

    Анализ:

    • Функция анализирует последние значения технических индикаторов для определения текущего тренда (бычий, медвежий, нейтральный) и вычисляет вероятность этого тренда на основе количества сигналов.
    • Рассчитывает точки входа и тейк-профита на основе ATR.

    Рекомендации:

    • Возможно, стоит добавить дополнительные правила для повышения точности анализа, например, учитывать кроссоверы более долгосрочных индикаторов.
    • Добавьте возможность настройки коэффициента ATR для расчета тейк-профита через конфигурационный файл.
    • Рассмотрите использование более сложных алгоритмов оценки вероятности тренда, таких как машинное обучение или взвешенные сигналы.

    8. Дополнительные проверки

    8.1 Проверка объема торгов

    def is_volume_sufficient(df, threshold=1000):
        """
        Проверяет, достаточен ли средний объем торгов за период.
    
        :param df: DataFrame с историческими данными.
        :param threshold: Минимальный средний объем торгов.
        :return: True если объем достаточен, иначе False.
        """
        average_volume = df['Volume'].mean()
        return average_volume >= threshold
    

    Анализ:

    • Функция проверяет, превышает ли средний объем торгов заданный порог.

    Рекомендации:

    • Добавьте возможность настройки порога через конфигурационный файл.
    • Рассмотрите использование более сложных метрик для оценки объема, например, сравнение с объемом за предыдущие периоды.

    8.2 Проверка вариации цен

    def has_sufficient_price_variation(df, min_variation=0.5):
        """
        Проверяет, есть ли достаточная вариация цен.
    
        :param df: DataFrame с историческими данными.
        :param min_variation: Мин. вариация в процентах.
        :return: True если вариация достаточна, иначе False.
        """
        price_diff = df['High'].max() - df['Low'].min()
        if df['Low'].min() == 0:
            return False  # Избежать деления на ноль
        percentage_variation = (price_diff / df['Low'].min()) * 100
        return percentage_variation >= min_variation
    

    Анализ:

    • Проверяет, превышает ли разница между максимальной и минимальной ценой за период минимальный процент вариации.

    Рекомендации:

    • Убедитесь, что расчет вариации корректен и соответствует вашим требованиям.
    • Рассмотрите использование других метрик вариации, например, стандартного отклонения.

    9. Функции для отправки отчета в Telegram

    9.1 Отправка отчета

    async def send_telegram_report(token, chat_id, bullish_symbols, bearish_symbols):
        bot = telegram.Bot(token=token)
        try:
            # Отправка списка монет с высокой вероятностью роста
            if bullish_symbols:
                message_growth = "📈 **Список монет с высокой вероятностью роста:**"
                logging.info("Отправка сообщения о монетах с высокой вероятностью роста.")
                await bot.send_message(chat_id=chat_id, text=message_growth, parse_mode='Markdown')
                logging.info(f"Отправка группы из {len(bullish_symbols)} графиков в Telegram для роста.")
                await send_media_group_with_retry(bot, chat_id, bullish_symbols)
            else:
                logging.info("Нет монет с высокой вероятностью роста для отправки.")
    
            # Отправка списка монет с высокой вероятностью падения
            if bearish_symbols:
                message_decline = "📉 **Список монет с высокой вероятностью падения:**"
                logging.info("Отправка сообщения о монетах с высокой вероятностью падения.")
                await bot.send_message(chat_id=chat_id, text=message_decline, parse_mode='Markdown')
                logging.info(f"Отправка группы из {len(bearish_symbols)} графиков в Telegram для падения.")
                await send_media_group_with_retry(bot, chat_id, bearish_symbols)
            else:
                logging.info("Нет монет с высокой вероятностью падения для отправки.")
    
            # Очистка директории графиков после отправки
            try:
                logging.info("Удаление отправленных графиков.")
                files = glob.glob(os.path.join(GRAPHS_DIR, '*_72h.png'))
                for file in files:
                    os.remove(file)
                logging.info(f"Удалено {len(files)} графиков.")
            except Exception as e:
                logging.error(f"Ошибка при удалении графиков: {e}")
    
            logging.info("Отчет успешно отправлен в Telegram.")
        except Exception as e:
            logging.error(f"Ошибка при отправке отчета в Telegram: {e}")
    

    Анализ:

    • Функция отправляет отчеты о монетах с бычьими и медвежьими трендами, включая группы медиа-файлов (графиков).
    • После отправки графиков они удаляются из директории graphs.

    Рекомендации:

    • Добавьте проверку на успешную отправку сообщений и графиков.
    • Рассмотрите возможность логирования полученных откликов от Telegram для мониторинга успешности отправок.

    9.2 Отправка медиа-группы с повторными попытками

    async def send_media_group_with_retry(bot, chat_id, symbols, retries=3, delay=5):
        """
        Отправляет группу медиа-файлов с повторными попытками в случае ошибок.
    
        :param bot: Экземпляр бота telegram.Bot.
        :param chat_id: ID чата для отправки.
        :param symbols: Список символов с информацией (направление, вероятность, изображение, entry, take_profit).
        :param retries: Количество попыток повторной отправки.
        :param delay: Задержка между попытками.
        :return: None
        """
        media_group = []
        for symbol_info in symbols:
            symbol = symbol_info['symbol']
            direction = symbol_info['direction']
            probability = symbol_info['probability']
            image_path = symbol_info['image']
            entry = symbol_info.get('entry')
            take_profit = symbol_info.get('take_profit')
    
            if image_path is None:
                logging.warning(f"Нет данных изображения для {symbol}. Пропуск.")
                continue
    
            # Создание подписи для графика
            if direction == "Бычий тренд":
                emoji = "📈"
            elif direction == "Медвежий тренд":
                emoji = "📉"
            else:
                emoji = "🔍"  # Нейтральный тренд
    
            if entry and take_profit:
                caption = (
                    f"{emoji} Монета: {symbol}\n"
                    f"🔺 Направление: {direction}\n"
                    f"🔢 Вероятность: {probability}\n"
                    f"📍 Точка входа: {entry:.2f} USDT\n"
                    f"🎯 Тейк-профит: {take_profit:.2f} USDT"
                )
            else:
                caption = (
                    f"{emoji} Монета: {symbol}\n"
                    f"🔺 Направление: {direction}\n"
                    f"🔢 Вероятность: {probability}"
                )
    
            # Добавление изображения и подписи в медиа-группу
            try:
                with open(image_path, 'rb') as photo_file:
                    media_group.append(InputMediaPhoto(photo_file, caption=caption))
            except Exception as e:
                logging.error(f"Ошибка при открытии изображения {image_path}: {e}")
                continue
    
            # Проверка, достигло ли количество медиа в группе лимита (10)
            if len(media_group) == 10:
                logging.info(f"Отправка группы из {len(media_group)} графиков в Telegram.")
                await send_media_group_with_retry_helper(bot, chat_id, media_group, retries, delay)
                media_group = []
                await asyncio.sleep(2)  # Увеличенная задержка между отправками
    
        # Отправка оставшихся графиков
        if media_group:
            logging.info(f"Отправка последней группы из {len(media_group)} графиков в Telegram.")
            await send_media_group_with_retry_helper(bot, chat_id, media_group, retries, delay)
            media_group = []
            await asyncio.sleep(2)  # Увеличенная задержка
    

    Анализ:

    • Функция собирает медиа-файлы в группы по 10 и отправляет их с использованием вспомогательной функции для повторных попыток.
    • Паузы между отправками предотвращают превышение лимитов Telegram.

    Рекомендации:

    • Telegram API позволяет отправлять медиа-группы до 10 элементов, что соблюдается в коде. Однако учитывайте общие лимиты API для предотвращения блокировок.
    • Добавьте обработку ситуаций, когда количество символов превышает лимиты по размеру медиа-группы или общего количества.

    9.3 Вспомогательная функция для отправки с повторными попытками

    async def send_media_group_with_retry_helper(bot, chat_id, media_group, retries, delay):
        attempt = 0
        while attempt < retries:
            try:
                await bot.send_media_group(chat_id=chat_id, media=media_group)
                logging.info(f"Группа медиа успешно отправлена (Попытка {attempt + 1}).")
                return
            except RetryAfter as e:
                logging.warning(f"Превышен лимит отправки. Попытка {attempt + 1} через {e.retry_after} секунд.")
                await asyncio.sleep(e.retry_after)
            except TimedOut:
                logging.warning(f"Таймаут при отправке группы медиа. Попытка {attempt + 1} через {delay} секунд.")
                await asyncio.sleep(delay)
            except TelegramError as e:
                logging.error(f"TelegramError при отправке группы медиа: {e}. Попытка {attempt + 1} через {delay} секунд.")
                await asyncio.sleep(delay)
            except Exception as e:
                logging.error(f"Неизвестная ошибка при отправке группы медиа: {e}. Попытка {attempt + 1} через {delay} секунд.")
                await asyncio.sleep(delay)
            attempt += 1
    
        logging.error("Не удалось отправить группу медиа после нескольких попыток.")
    

    Анализ:

    • Функция пытается отправить медиа-группу несколько раз в случае ошибок, соблюдая задержки и обрабатывая специфичные ошибки Telegram.
    • Это повышает надежность отправок, особенно при временных проблемах с сетью или API.

    Рекомендации:

    • Рассмотрите возможность увеличения числа попыток или изменения стратегии задержек (например, применение экспоненциального backoff).
    • Логируйте более детальную информацию о типах ошибок для упрощения отладки.

    10. Обработка каждого символа

    async def process_symbol(session, symbol, semaphore, executor):
        async with semaphore:
            try:
                df = await get_historical_klines(session, symbol, '1h', 72)
                if df is None или len(df) < 50:  # Убедиться, что данных достаточно для SMA50
                    logging.warning(f"Недостаточно данных для анализа {symbol}. Пропуск.")
                    return None
    
                # Добавляем проверку объема торгов
                if not is_volume_sufficient(df):
                    logging.info(f"Объем торгов для {symbol} ниже порога. Пропуск.")
                    return None
    
                # Добавляем проверку вариации цен
                if not has_sufficient_price_variation(df):
                    logging.info(f"Вариация цен для {symbol} ниже порога. Пропуск.")
                    return None
    
                # Вычисление индикаторов (ограничено потоком для безопасности с Pandas и TA)
                loop = asyncio.get_event_loop()
                df = await loop.run_in_executor(executor, compute_indicators, df)
    
                # Анализ индикаторов
                direction, probability, entry_price, take_profit = await loop.run_in_executor(executor, analyze_indicators, df)
    
                # Проверка вероятности продолжения тренда
                if probability != "N/A":
                    try:
                        prob_value = float(probability.split('%')[0])
                    except ValueError:
                        logging.warning(f"Некорректное значение вероятности для {symbol}: {probability}. Пропуск.")
                        return None
    
                    if prob_value >= 80.0:
                        logging.info(f"Монета {symbol} соответствует критерию (prob={probability}).")
    
                        # Построение графика с точками входа и тейк-профита (ограничено потоком для безопасности с Matplotlib и PIL)
                        image_path = await loop.run_in_executor(executor, plot_candlestick, df, symbol, entry_price, take_profit)
                        if image_path is None:
                            logging.warning(f"График для {symbol} не создан. Пропуск.")
                            return None
    
                        # Формирование информации для Telegram
                        return {
                            'symbol': symbol,
                            'direction': direction,
                            'probability': probability,
                            'image': image_path,
                            'entry': entry_price,
                            'take_profit': take_profit
                        }
    
                return None
    
            except Exception as e:
                logging.error(f"Ошибка при обработке символа {symbol}: {e}")
                return None
    

    Анализ:

    • Функция обрабатывает каждый символ: получает данные, проводит проверки, вычисляет индикаторы, анализирует тренд и создает графики при соответствии критериям.
    • Использует семафор для ограничения количества одновременных задач и ThreadPoolExecutor для выполнения блокирующих операций в отдельном потоке.

    Рекомендации:

    • Убедитесь, что обработка символов оптимизирована для большого количества пар, если требуется.
    • Добавьте более детализированную обработку ошибок для различных этапов процесса.
    • Рассмотрите возможность кеширования результатов для символов, которые уже были обработаны недавно.

    11. Основная функция

    async def main():
        try:
            # Очистка предыдущих графиков перед запуском
            clean_previous_graphs()
    
            # Создание сессии aiohttp
            connector = aiohttp.TCPConnector(limit=100)  # Настройте лимит под ваши нужды
            async with aiohttp.ClientSession(connector=connector) as session:
                symbols = await get_future_symbols(session)
                bullish_symbols = []
                bearish_symbols = []
    
                # Ограничение количества одновременных задач
                semaphore = asyncio.Semaphore(20)  # Настройте под ваши нужды
                executor = ThreadPoolExecutor(max_workers=10)  # Настройте под ваши нужды
    
                # Создание списка задач для обработки символов
                tasks = [
                    process_symbol(session, symbol, semaphore, executor) for symbol in symbols
                ]
    
                # Параллельное выполнение задач
                results = await asyncio.gather(*tasks)
    
                # Обработка результатов
                for result in results:
                    if result is None:
                        continue
                    if result['direction'] == "Бычий тренд":
                        bullish_symbols.append(result)
                    elif result['direction'] == "Медвежий тренд":
                        bearish_symbols.append(result)
    
                if bullish_symbols or bearish_symbols:
                    # Отправка отчетных графиков в Telegram
                    logging.info(f"Отправка отчета с {len(bullish_symbols)} монетами для роста и {len(bearish_symbols)} монетами для падения.")
                    await send_telegram_report(config.TELEGRAM_TOKEN, config.CHAT_ID, bullish_symbols, bearish_symbols)
                else:
                    logging.info("Нет монет, соответствующих критериям для отчета.")
    
                logging.info("Процесс завершен успешно.")
        except Exception as e:
            logging.error(f"Процесс завершился с ошибкой: {e}")
    

    Анализ:

    • Функция orchestrates основную логику: очищает предыдущие графики, создает сессию для HTTP-запросов, получает список символов, создает и выполняет задачи для обработки каждого символа, собирает результаты и отправляет отчеты в Telegram.
    • Настройки aiohttp.TCPConnector, Semaphore и ThreadPoolExecutor позволяют контролировать количество одновременных подключений и вычислений, предотвращая перегрузку системы и API.

    Рекомендации:

    • Проверьте, оптимальны ли текущие значения лимитов подключения и семафора для вашего окружения и требований.
    • Добавьте механизмы мониторинга и оповещения о падениях или неудачных попытках обработки.
    • Рассмотрите возможность периодического запуска этого скрипта (например, через cron или systemd), если это необходимо для регулярного анализа.

    12. Запуск скрипта

    if __name__ == '__main__':
        asyncio.run(main())
    

    Анализ:

    • Используется asyncio.run для запуска основной асинхронной функции main().

    Рекомендации:

    • Убедитесь, что скрипт запускается в подходящей среде с поддержкой asyncio.
    • Рассмотрите добавление более подробного сообщения при старте и остановке скрипта для лучшего мониторинга.

    Общие замечания и рекомендации

    1. Конфигурация:

      • Все параметры, такие как токен Telegram, ID чата, пороги объемов и вариаций валют, значения окон индикаторов и другие настройки, должны быть вынесены в конфигурационный файл (config.py) или использовать переменные окружения. Это повысит гибкость и удобство настройки.
    2. Обработка ошибок:

      • Хотя скрипт содержит базовую обработку ошибок, стоит добавить более детализированные сообщения и, возможно, оповещения при критических ошибках.
      • Рассмотрите возможность использования сторонних сервисов для мониторинга (например, Sentry) для отслеживания и уведомления о непредвиденных ошибках.
    3. Оптимизация производительности:

      • Проверьте, не возникают ли узкие места при обработке большого количества символов. Возможно, потребуется увеличить количество рабочих потоков или оптимизировать вычисления.
      • Используйте профилирование для выявления медленных частей кода и их оптимизации.
    4. Безопасность:

      • Храните токены и чувствительные данные в безопасных местах, например, используя переменные окружения или секретные хранилища.
      • Убедитесь, что доступ к логам и сохраненным графикам защищен от несанкционированного доступа.
    5. Тестирование:

      • Разработайте набор тестов для проверки отдельных компонентов скрипта, таких как функции получения данных, вычисления индикаторов и отправки отчетов.
      • Используйте мокирование (mocking) для имитации ответов от Binance и Telegram при тестировании.
    6. Документация:

      • Добавьте подробные комментарии и документацию к каждому компоненту скрипта, чтобы облегчить поддержку и дальнейшее развитие кода.
      • Создайте README-файл с инструкциями по установке, настройке и запуску бота.
    7. Логирование:

      • Рассмотрите возможность добавления метрик (например, с помощью Prometheus и Grafana) для мониторинга производительности и состояния бота в реальном времени.
    8. Обновления и поддержка:

      • Регулярно проверяйте обновления используемых библиотек, особенно тех, которые связаны с Binance API и Telegram, чтобы избежать несовместимостей.
      • Следите за изменениями в API Binance и Telegram, чтобы своевременно адаптировать скрипт под новые требования.

    Заключение

    Ваш скрипт имеет хорошо структурированную логику и охватывает ключевые аспекты автоматизированного анализа и отправки данных в Telegram. Внимание к деталям, таких как обработка ошибок, проверка данных и оптимизация производительности, делает его надежным инструментом. Следуя приведенным рекомендациям, вы сможете повысить его эффективность, безопасность и удобство эксплуатации.

    Если у вас есть конкретные вопросы или требуется помощь в реализации каких-либо изменений, пожалуйста, дайте знать!