Update app.py

app.py

@@ -1,164 +1,762 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
 import ccxt
 import pandas as pd
+import numpy as np
+import time
 import asyncio
 import logging
-import httpx
-from tenacity import retry, wait_exponential, stop_after_attempt
-from telegram import Bot
-from telegram.error import TelegramError
-from ta.momentum import RSIIndicator
-from ta.trend import EMAIndicator
-import config
+import json
+import os
+import math
+import talib
+import telegram
+from telegram.ext import Updater, CommandHandler, MessageHandler, Filters
+from datetime import datetime, timedelta
+import threading
+import schedule
+import warnings
+import requests
+from collections import defaultdict
+import matplotlib.pyplot as plt
+import matplotlib
+import io
+from config import Config
+
+# تنظیم matplotlib برای پشتیبانی از زبان فارسی
+matplotlib.rc('font', family='DejaVu Sans')
 
+# تنظیمات لاگینگ
 logging.basicConfig(
+    level=logging.INFO,
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    level=logging.INFO
+    handlers=[
+        logging.FileHandler("crypto_analyzer.log", encoding='utf-8'),
+        logging.StreamHandler()
+    ]
 )
 logger = logging.getLogger(__name__)
 
-class LBankMonitor:
-    def __init__(self):
-        self.http_client = httpx.AsyncClient(
-            limits=httpx.Limits(
-                max_connections=config.HTTP_CONFIG['max_connections'],
-                max_keepalive_connections=config.HTTP_CONFIG['max_keepalive']
-            ),
-            timeout=config.HTTP_CONFIG['timeout']
-        )
-        
-        self.exchange = ccxt.lbank({
-            'apiKey': config.API_CONFIG['apiKey'],
-            'secret': config.API_CONFIG['secret'],
-            'enableRateLimit': True,
-            'session': self.http_client
-        })
-        
-        self.bot = Bot(token=config.TELEGRAM_CONFIG['bot_token'])
-        self.semaphore = asyncio.Semaphore(config.THROTTLING['max_parallel'])
-        self.connected = False
+# اخطارهای غیرضروری را نادیده بگیر
+warnings.filterwarnings("ignore")
 
-    @retry(wait=wait_exponential(multiplier=1, min=2, max=10), stop=stop_after_attempt(3))
-    async def fetch_ohlcv(self, symbol, timeframe):
-        async with self.semaphore:
-            try:
-                ohlcv = await self.exchange.fetch_ohlcv(symbol, timeframe)
-                df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
-                df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
-                return df
-            except Exception as e:
-                logger.error(f"Error fetching {symbol} ({timeframe}): {str(e)}")
-                raise
+class CryptoAnalyzer:
+    def __init__(self, config_path="config.json"):
+        """مقداردهی اولیه کلاس تحلیلگر ارزهای دیجیتال"""
+        try:
+            # بارگیری تنظیمات
+            self.config = Config()
+            
+            # تنظیمات صرافی
+            self.exchange = ccxt.lbank({
+                'apiKey': self.config.API_KEY,
+                'secret': self.config.SECRET_KEY,
+                'enableRateLimit': True,
+                'options': {'defaultType': 'spot'}
+            })
+            
+            # دیکشنری برای ذخیره داده‌های بازار
+            self.market_data = {}
+            
+            # لیست ارزهای تحت نظارت
+            self.symbols = self.config.SYMBOLS
+            
+            # تایم فریم‌ها
+            self.timeframes = self.config.TIMEFRAMES
+            
+            # تنظیمات تلگرام
+            self.bot = telegram.Bot(token=self.config.TELEGRAM_TOKEN)
+            self.chat_id = self.config.TELEGRAM_CHAT_ID
+            
+            # وضعیت اتصال
+            self.is_connected = False
+            
+            # دیکشنری برای ذخیره سیگنال‌های فعال
+            self.active_signals = {}
+            
+            # بررسی اتصال به صرافی
+            self.check_exchange_connection()
+            
+            logger.info("🔄 سیستم تحلیلگر ارزهای دیجیتال با موفقیت راه‌اندازی شد!")
+            self.send_telegram_message("🔄 سیستم تحلیلگر ارزهای دیجیتال با موفقیت راه‌اندازی شد!")
+            
+        except Exception as e:
+            logger.error(f"خطا در راه‌اندازی سیستم: {str(e)}")
+            self.send_telegram_message(f"❌ خطا در راه‌اندازی سیستم: {str(e)}")
+
+    def check_exchange_connection(self):
+        """بررسی اتصال به صرافی"""
+        try:
+            self.exchange.load_markets()
+            self.is_connected = True
+            logger.info("✅ اتصال به صرافی با موفقیت برقرار شد!")
+            self.send_telegram_message("✅ اتصال به صرافی با موفقیت برقرار شد!")
+            return True
+        except Exception as e:
+            self.is_connected = False
+            logger.error(f"❌ خطا در اتصال به صرافی: {str(e)}")
+            self.send_telegram_message(f"❌ خطا در اتصال به صرافی: {str(e)}")
+            return False
+
+    async def fetch_ohlcv_data(self, symbol, timeframe):
+        """دریافت داده‌های OHLCV برای یک ارز در یک تایم فریم خاص"""
+        try:
+            limit = 100  # تعداد کندل‌ها
+            ohlcv = self.exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
+            df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
+            df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
+            df.set_index('timestamp', inplace=True)
+            
+            if symbol not in self.market_data:
+                self.market_data[symbol] = {}
+            
+            self.market_data[symbol][timeframe] = df
+            logger.debug(f"داده‌های {symbol} در تایم فریم {timeframe} با موفقیت دریافت شد.")
+            
+            return df
+        except Exception as e:
+            logger.error(f"خطا در دریافت داده‌های {symbol} در تایم فریم {timeframe}: {str(e)}")
+            return None
+
+    async def fetch_order_book(self, symbol):
+        """دریافت اردربوک برای یک ارز"""
+        try:
+            order_book = self.exchange.fetch_order_book(symbol)
+            return order_book
+        except Exception as e:
+            logger.error(f"خطا در دریافت اردربوک {symbol}: {str(e)}")
+            return None
 
     def calculate_indicators(self, df):
-        df['rsi'] = RSIIndicator(df['close']).rsi()
-        df['ema20'] = EMAIndicator(df['close'], window=20).ema_indicator()
-        df['ema50'] = EMAIndicator(df['close'], window=50).ema_indicator()
-        return df
-
-    async def analyze_symbol(self, symbol):
-        try:
-            signals = []
-            for tf in config.TIMEFRAMES:
-                df = await self.fetch_ohlcv(symbol, tf)
-                if df is not None and not df.empty:
-                    df = self.calculate_indicators(df)
-                    current_close = df['close'].iloc[-1]
-                    rsi = df['rsi'].iloc[-1]
+        """محاسبه شاخص‌های تکنیکال مختلف"""
+        try:
+            # محاسبه RSI
+            df['rsi'] = talib.RSI(df['close'], timeperiod=14)
+            
+            # محاسبه MACD
+            macd, macd_signal, macd_hist = talib.MACD(df['close'])
+            df['macd'] = macd
+            df['macd_signal'] = macd_signal
+            df['macd_hist'] = macd_hist
+            
+            # محاسبه میانگین متحرک
+            df['sma_20'] = talib.SMA(df['close'], timeperiod=20)
+            df['sma_50'] = talib.SMA(df['close'], timeperiod=50)
+            df['sma_200'] = talib.SMA(df['close'], timeperiod=200)
+            
+            # محاسبه Bollinger Bands
+            df['upper_band'], df['middle_band'], df['lower_band'] = talib.BBANDS(df['close'], timeperiod=20)
+            
+            # محاسبه MFI (Money Flow Index)
+            df['mfi'] = talib.MFI(df['high'], df['low'], df['close'], df['volume'], timeperiod=14)
+            
+            # محاسبه ATR (Average True Range)
+            df['atr'] = talib.ATR(df['high'], df['low'], df['close'], timeperiod=14)
+            
+            return df
+        except Exception as e:
+            logger.error(f"خطا در محاسبه شاخص‌ها: {str(e)}")
+            return df
+
+    def calculate_volume_profile(self, df):
+        """تحلیل پروفایل حجم معاملات"""
+        try:
+            # تقسیم محدوده قیمت به ۱۰ دسته
+            price_range = df['high'].max() - df['low'].min()
+            bin_size = price_range / 10
+            
+            price_bins = []
+            volume_bins = []
+            
+            for i in range(10):
+                lower = df['low'].min() + i * bin_size
+                upper = lower + bin_size
+                mask = (df['close'] >= lower) & (df['close'] < upper)
+                volume_in_bin = df.loc[mask, 'volume'].sum()
+                
+                price_bins.append((lower + upper) / 2)
+                volume_bins.append(volume_in_bin)
+            
+            return {
+                'price_bins': price_bins,
+                'volume_bins': volume_bins
+            }
+        except Exception as e:
+            logger.error(f"خطا در محاسبه پروفایل حجم: {str(e)}")
+            return None
+
+    def calculate_delta(self, symbol, timeframe):
+        """محاسبه دلتا (تفاوت بین حجم خرید و فروش)"""
+        try:
+            df = self.market_data[symbol][timeframe]
+            
+            # محاسبه دلتا ساده با استفاده از تغییرات قیمت و حجم
+            df['delta'] = np.where(df['close'] > df['open'], df['volume'], -df['volume'])
+            df['cumulative_delta'] = df['delta'].cumsum()
+            
+            # محاسبه دلتا ریورس
+            df['reverse_delta'] = -df['delta']
+            df['cumulative_reverse_delta'] = df['reverse_delta'].cumsum()
+            
+            return df['cumulative_delta'].iloc[-1], df['cumulative_reverse_delta'].iloc[-1]
+        except Exception as e:
+            logger.error(f"خطا در محاسبه دلتا برای {symbol} در تایم فریم {timeframe}: {str(e)}")
+            return 0, 0
+
+    def analyze_bid_ask(self, order_book):
+        """تحلیل بید اسک (خرید و فروش) از اطلاعات اردربوک"""
+        try:
+            # محاسبات بید اسک
+            bids = order_book['bids']
+            asks = order_book['asks']
+            
+            # مجموع حجم در سمت خرید و فروش
+            total_bid_volume = sum([bid[1] for bid in bids[:10]])
+            total_ask_volume = sum([ask[1] for ask in asks[:10]])
+            
+            # نسبت حجم خرید به فروش
+            bid_ask_ratio = total_bid_volume / total_ask_volume if total_ask_volume > 0 else float('inf')
+            
+            # فشار خرید یا فروش
+            if bid_ask_ratio > 1.5:
+                pressure = "خرید"
+                pressure_strength = min(bid_ask_ratio / 5, 1.0)  # نرمال‌سازی قدرت
+            elif bid_ask_ratio < 0.67:
+                pressure = "فروش"
+                pressure_strength = min((1 / bid_ask_ratio) / 5, 1.0)  # نرمال سازی قدرت
+            else:
+                pressure = "خنثی"
+                pressure_strength = 0.0
+                
+            return {
+                'bid_ask_ratio': bid_ask_ratio,
+                'pressure': pressure,
+                'pressure_strength': pressure_strength
+            }
+        except Exception as e:
+            logger.error(f"خطا در تحلیل بید اسک: {str(e)}")
+            return {
+                'bid_ask_ratio': 1.0,
+                'pressure': "خنثی",
+                'pressure_strength': 0.0
+            }
+
+    def analyze_order_flow(self, symbol, timeframes):
+        """تحلیل جریان سفارشات (Order Flow) برای یک ارز در تایم فریم‌های مختلف"""
+        order_flow_score = 0
+        try:
+            order_book = asyncio.run(self.fetch_order_book(symbol))
+            if not order_book:
+                return 0
+                
+            bid_ask_analysis = self.analyze_bid_ask(order_book)
+            
+            # جمع آوری دلتا از تمام تایم فریم‌ها
+            total_delta = 0
+            for tf in timeframes:
+                if symbol in self.market_data and tf in self.market_data[symbol]:
+                    delta, _ = self.calculate_delta(symbol, tf)
+                    # وزن دهی به دلتا بر اساس تایم فریم
+                    weight = {'1m': 0.1, '5m': 0.15, '15m': 0.2, '30m': 0.25, '1h': 0.3}.get(tf, 0.2)
+                    total_delta += delta * weight
+            
+            # ترکیب دلتا با تحلیل بید اسک
+            if bid_ask_analysis['pressure'] == "خرید" and total_delta > 0:
+                order_flow_score = 0.5 + bid_ask_analysis['pressure_strength'] * 0.5
+            elif bid_ask_analysis['pressure'] == "فروش" and total_delta < 0:
+                order_flow_score = -0.5 - bid_ask_analysis['pressure_strength'] * 0.5
+            else:
+                order_flow_score = total_delta / (abs(total_delta) + 1) * 0.3  # نرمال سازی بین -0.3 و 0.3
+                
+            return order_flow_score
+        except Exception as e:
+            logger.error(f"خطا در تحلیل جریان سفارشات برای {symbol}: {str(e)}")
+            return order_flow_score
+
+    def analyze_elliott_waves(self, df):
+        """تحلیل امواج الیوت"""
+        try:
+            # این یک تقریب ساده از تحلیل امواج الیوت است
+            # برای تحلیل دقیق، الگوریتم‌های پیچیده‌تری نیاز است
+            
+            # پیدا کردن نقاط اوج و فرود اخیر
+            prices = df['close'].values
+            window_size = 5
+            peaks = []
+            troughs = []
+            
+            for i in range(window_size, len(prices) - window_size):
+                if all(prices[i] > prices[i-j] for j in range(1, window_size+1)) and all(prices[i] > prices[i+j] for j in range(1, window_size+1)):
+                    peaks.append((i, prices[i]))
+                if all(prices[i] < prices[i-j] for j in range(1, window_size+1)) and all(prices[i] < prices[i+j] for j in range(1, window_size+1)):
+                    troughs.append((i, prices[i]))
+            
+            # حداقل ۵ نقطه ��رای تحلیل موج الیوت نیاز است
+            if len(peaks) < 3 or len(troughs) < 2:
+                return {
+                    'wave_pattern': 'نامشخص',
+                    'confidence': 0.0,
+                    'potential_direction': 'خنثی'
+                }
+            
+            # مرتب‌سازی براساس زمان
+            all_points = sorted(peaks + troughs, key=lambda x: x[0])
+            
+            # تلاش برای تشخیص الگوهای امواج الیوت ۵-۳
+            if len(all_points) >= 5:
+                # بررسی اینکه آیا ۵ موج رو به بالا داریم
+                if all_points[0][1] < all_points[1][1] > all_points[2][1] < all_points[3][1] > all_points[4][1]:
+                    # احتمالا در موج ۵ صعودی هستیم
+                    return {
+                        'wave_pattern': 'موج 5 صعودی',
+                        'confidence': 0.7,
+                        'potential_direction': 'نزولی'  # پس از موج ۵ صعودی، احتمال نزول وجود دارد
+                    }
+                elif all_points[0][1] > all_points[1][1] < all_points[2][1] > all_points[3][1] < all_points[4][1]:
+                    # احتمالا در موج ۵ نزولی هستیم
+                    return {
+                        'wave_pattern': 'موج 5 نزولی',
+                        'confidence': 0.7,
+                        'potential_direction': 'صعودی'  # پس از موج ۵ نزولی، احتمال صعود وجود دارد
+                    }
+            
+            # اگر الگوی مشخصی شناسایی نشد
+            return {
+                'wave_pattern': 'در حال تشکیل',
+                'confidence': 0.3,
+                'potential_direction': 'نامشخص'
+            }
+        except Exception as e:
+            logger.error(f"خطا در تحلیل امواج الیوت: {str(e)}")
+            return {
+                'wave_pattern': 'خطا',
+                'confidence': 0.0,
+                'potential_direction': 'خنثی'
+            }
+
+    def analyze_footprint(self, symbol, timeframe):
+        """تحلیل فوت‌پرینت (نقشه حرارتی معاملات)"""
+        try:
+            df = self.market_data[symbol][timeframe]
+            
+            # تجزیه و تحلیل بر اساس تغییرات قیمت و حجم
+            df['price_change'] = df['close'] - df['open']
+            df['normalized_volume'] = df['volume'] / df['volume'].mean()
+            
+            # شناسایی کندل‌های مهم با حجم بالا
+            high_volume_candles = df[df['normalized_volume'] > 1.5]
+            
+            # محاسبه نسبت کندل‌های صعودی پرحجم به کل کندل‌های پرحجم
+            if len(high_volume_candles) > 0:
+                bullish_ratio = len(high_volume_candles[high_volume_candles['price_change'] > 0]) / len(high_volume_candles)
+            else:
+                bullish_ratio = 0.5
+            
+            # نمره دهی به فوت‌پرینت
+            if bullish_ratio > 0.7:
+                footprint_score = (bullish_ratio - 0.5) * 2  # نرمال سازی بین 0 و 1
+                direction = "صعودی"
+            elif bullish_ratio < 0.3:
+                footprint_score = ((0.5 - bullish_ratio) * 2) * -1  # نرمال سازی بین -1 و 0
+                direction = "نزولی"
+            else:
+                footprint_score = (bullish_ratio - 0.5) * 2  # بین -0.4 و 0.4
+                direction = "خنثی"
+                
+            return {
+                'footprint_score': footprint_score,
+                'direction': direction,
+                'high_volume_candles_count': len(high_volume_candles)
+            }
+        except Exception as e:
+            logger.error(f"خطا در تحلیل فوت‌پرینت برای {symbol} در تایم فریم {timeframe}: {str(e)}")
+            return {
+                'footprint_score': 0,
+                'direction': "خنثی",
+                'high_volume_candles_count': 0
+            }
+
+    def analyze_poc(self, symbol, timeframe):
+        """تحلیل نقطه کنترل قیمت (Point of Control)"""
+        try:
+            df = self.market_data[symbol][timeframe]
+            
+            # محاسبه پروفایل حجم
+            volume_profile = self.calculate_volume_profile(df)
+            if not volume_profile:
+                return {
+                    'poc_price': df['close'].iloc[-1],
+                    'distance_from_poc': 0,
+                    'poc_significance': 0
+                }
+                
+            # پیدا کردن قیمت با بیشترین حجم (POC)
+            max_volume_index = np.argmax(volume_profile['volume_bins'])
+            poc_price = volume_profile['price_bins'][max_volume_index]
+            
+            # محاسبه فاصله از POC
+            current_price = df['close'].iloc[-1]
+            distance_from_poc = (current_price - poc_price) / poc_price * 100
+            
+            # محاسبه اهمیت POC (بر اساس نسبت حجم در POC به میانگین حجم)
+            avg_volume = np.mean(volume_profile['volume_bins'])
+            max_volume = volume_profile['volume_bins'][max_volume_index]
+            poc_significance = max_volume / avg_volume if avg_volume > 0 else 1
+            
+            return {
+                'poc_price': poc_price,
+                'distance_from_poc': distance_from_poc,
+                'poc_significance': min(poc_significance / 3, 1.0)  # نرمال‌سازی بین 0 و 1
+            }
+        except Exception as e:
+            logger.error(f"خطا در تحلیل POC برای {symbol} در تایم فریم {timeframe}: {str(e)}")
+            return {
+                'poc_price': 0,
+                'distance_from_poc': 0,
+                'poc_significance': 0
+            }
+
+    def generate_trading_signal(self, symbol):
+        """تولید سیگنال معاملاتی برای یک ارز بر اساس تحلیل‌های انجام شده"""
+        try:
+            # جمع‌آوری نتایج تحلیل‌ها از تمام تایم فریم‌ها
+            timeframe_analysis = {}
+            signal_strength = 0
+            signal_direction = "خنثی"
+            
+            for tf in self.timeframes:
+                # بررسی وجود داده برای این تایم فریم
+                if symbol not in self.market_data or tf not in self.market_data[symbol]:
+                    continue
                     
-                    # منطق پیشرفته تحلیل (نمونه)
-                    if rsi < config.THRESHOLDS['rsi_oversold']:
-                        signals.append({
-                            'symbol': symbol,
-                            'timeframe': tf,
-                            'signal': 'خرید',
-                            'confidence': 95,
-                            'price': current_close
-                        })
-            return signals
-        except Exception as e:
-            logger.error(f"Analysis failed for {symbol}: {str(e)}")
-            return []
-
-    async def send_telegram(self, message):
-        try:
-            emojis = {
-                'خرید': '🟢💰', 'فروش': '🔴📉',
-                'اتصال': '🌐', 'خطا': '❌'
+                df = self.market_data[symbol][tf]
+                
+                # وزن تایم فریم در تحلیل نهایی
+                tf_weight = {'1m': 0.05, '5m': 0.1, '15m': 0.2, '30m': 0.25, '1h': 0.4}.get(tf, 0.2)
+                
+                # تحلیل‌های مختلف
+                order_flow_score = self.analyze_order_flow(symbol, [tf])
+                footprint_analysis = self.analyze_footprint(symbol, tf)
+                poc_analysis = self.analyze_poc(symbol, tf)
+                elliott_analysis = self.analyze_elliott_waves(df)
+                
+                # تحلیل شاخص‌های تکنیکال
+                rsi = df['rsi'].iloc[-1] if 'rsi' in df.columns else 50
+                macd_hist = df['macd_hist'].iloc[-1] if 'macd_hist' in df.columns else 0
+                
+                # محاسبه امتیاز نهایی تایم فریم
+                tf_score = 0
+                
+                # امتیاز بر اساس RSI
+                if rsi > 70:
+                    tf_score -= 0.3  # اشباع خرید
+                elif rsi < 30:
+                    tf_score += 0.3  # اشباع فروش
+                elif rsi > 60:
+                    tf_score += 0.1  # روند صعودی
+                elif rsi < 40:
+                    tf_score -= 0.1  # روند نزولی
+                
+                # امتیاز بر اساس MACD
+                if macd_hist > 0 and macd_hist > df['macd_hist'].iloc[-2]:
+                    tf_score += 0.2  # سیگنال صعودی قوی
+                elif macd_hist > 0:
+                    tf_score += 0.1  # سیگنال صعودی
+                elif macd_hist < 0 and macd_hist < df['macd_hist'].iloc[-2]:
+                    tf_score -= 0.2  # سیگنال نزولی قوی
+                elif macd_hist < 0:
+                    tf_score -= 0.1  # سیگنال نزولی
+                
+                # امتیاز بر اساس میانگین متحرک
+                if 'sma_20' in df.columns and 'sma_50' in df.columns:
+                    if df['close'].iloc[-1] > df['sma_20'].iloc[-1] > df['sma_50'].iloc[-1]:
+                        tf_score += 0.2  # روند صعودی قوی
+                    elif df['close'].iloc[-1] < df['sma_20'].iloc[-1] < df['sma_50'].iloc[-1]:
+                        tf_score -= 0.2  # روند نزولی قوی
+                
+                # امتیاز بر اساس Order Flow
+                tf_score += order_flow_score
+                
+                # امتیاز بر اساس Footprint
+                tf_score += footprint_analysis['footprint_score']
+                
+                # امتیاز بر اساس POC
+                if poc_analysis['distance_from_poc'] < 0 and poc_analysis['poc_significance'] > 0.5:
+                    tf_score += 0.2  # قیمت زیر POC با اهمیت بالا
+                elif poc_analysis['distance_from_poc'] > 0 and poc_analysis['poc_significance'] > 0.5:
+                    tf_score -= 0.2  # قیمت بالای POC با اهمیت بالا
+                
+                # امتیاز بر اساس امواج الیوت
+                if elliott_analysis['potential_direction'] == "صعودی":
+                    tf_score += 0.3 * elliott_analysis['confidence']
+                elif elliott_analysis['potential_direction'] == "نزولی":
+                    tf_score -= 0.3 * elliott_analysis['confidence']
+                
+                # ذخیره نتیجه تحلیل تایم فریم
+                timeframe_analysis[tf] = {
+                    'score': tf_score,
+                    'order_flow': order_flow_score,
+                    'footprint': footprint_analysis,
+                    'poc': poc_analysis,
+                    'elliott': elliott_analysis
+                }
+                
+                # افزودن امتیاز تایم فریم به امتیاز کلی با اعمال وزن
+                signal_strength += tf_score * tf_weight
+            
+            # تعیین جهت سیگنال
+            if signal_strength > 0.3:
+                signal_direction = "خرید"
+            elif signal_strength < -0.3:
+                signal_direction = "فروش"
+                
+            # تعیین قدرت سیگنال (بین 90% تا 100%)
+            normalized_strength = min(abs(signal_strength) * 10 / 8, 1.0)  # نرمال‌سازی
+            signal_strength_percent = 90 + (normalized_strength * 10)
+            
+            # محاسبه حد سود و حد ضرر
+            current_price = self.market_data[symbol]['1h']['close'].iloc[-1]
+            atr = self.market_data[symbol]['1h']['atr'].iloc[-1] if 'atr' in self.market_data[symbol]['1h'].columns else current_price * 0.01
+            
+            if signal_direction == "خرید":
+                stop_loss = current_price - (atr * 2)
+                take_profit = current_price + (atr * 4)
+            elif signal_direction == "فروش":
+                stop_loss = current_price + (atr * 2)
+                take_profit = current_price - (atr * 4)
+            else:
+                stop_loss = 0
+                take_profit = 0
+            
+            # تعیین مدت زمان ماندن در معامله (حداکثر ۶ ساعت)
+            if signal_strength_percent > 97:
+                duration_hours = 6
+            elif signal_strength_percent > 95:
+                duration_hours = 4
+            else:
+                duration_hours = 2
+                
+            return {
+                'symbol': symbol,
+                'direction': signal_direction,
+                'strength': signal_strength_percent,
+                'entry_price': current_price,
+                'stop_loss': stop_loss,
+                'take_profit': take_profit,
+                'duration_hours': duration_hours,
+                'analysis': timeframe_analysis,
+                'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
             }
-            for k, v in emojis.items():
-                if k in message:
-                    message = f"{v} {message}"
-                    break
+        except Exception as e:
+            logger.error(f"خطا در تولید سیگنال معاملاتی برای {symbol}: {str(e)}")
+            return None
+
+    def should_send_signal(self, signal):
+        """تصمیم‌گیری برای ارسال سیگنال بر اساس قدرت آن و وضعیت سیگنال‌های قبلی"""
+        try:
+            # اگر سیگنال خنثی است، ارسال نکن
+            if signal['direction'] == "خنثی":
+                return False
+                
+            # بررسی قدرت سیگنال
+            if signal['strength'] < 90:
+                return False
+                
+            # بررسی عدم تکرار سیگنال‌ها در زمان کوتاه
+            symbol = signal['symbol']
+            if symbol in self.active_signals:
+                last_signal = self.active_signals[symbol]
+                time_diff = datetime.now() - datetime.strptime(last_signal['timestamp'], '%Y-%m-%d %H:%M:%S')
+                
+                # اگر کمتر از ۲ ساعت از سیگنال قبلی گذشته باشد و جهت یکسان باشد
+                if time_diff.total_seconds() < 7200 and last_signal['direction'] == signal['direction']:
+                    return False
+                    
+                # اگر قدرت سیگنال جدید کمتر از سیگن��ل قبلی باشد
+                if signal['strength'] <= last_signal['strength'] and time_diff.total_seconds() < 14400:
+                    return False
             
-            await self.bot.send_message(
-                chat_id=config.TELEGRAM_CONFIG['chat_id'],
+            return True
+        except Exception as e:
+            logger.error(f"خطا در تصمیم‌گیری برای ارسال سیگنال: {str(e)}")
+            return False
+
+    def create_signal_chart(self, symbol):
+        """ایجاد نمودار برای سیگنال معاملاتی"""
+        try:
+            if symbol not in self.market_data or '1h' not in self.market_data[symbol]:
+                return None
+                
+            df = self.market_data[symbol]['1h'].copy()
+            
+            # رسم نمودار
+            plt.figure(figsize=(10, 6))
+            
+            # نمودار قیمت بسته شدن
+            plt.plot(df.index[-30:], df['close'].values[-30:], label='قیمت', color='blue')
+            
+            # اضافه کردن میانگین متحرک
+            if 'sma_20' in df.columns and 'sma_50' in df.columns:
+                plt.plot(df.index[-30:], df['sma_20'].values[-30:], label='SMA 20', color='orange', alpha=0.7)
+                plt.plot(df.index[-30:], df['sma_50'].values[-30:], label='SMA 50', color='red', alpha=0.7)
+            
+            # تنظیمات نمودار
+            plt.title(f"تحلیل ارز {symbol}", fontsize=14)
+            plt.grid(True, alpha=0.3)
+            plt.legend()
+            
+            # ذخیره نمودار در حافظه
+            buf = io.BytesIO()
+            plt.savefig(buf, format='png', dpi=100)
+            plt.close()
+            buf.seek(0)
+            
+            return buf
+        except Exception as e:
+            logger.error(f"خطا در ایجاد نمودار برای {symbol}: {str(e)}")
+            return None
+
+    def send_signal_to_telegram(self, signal):
+        """ارسال سیگنال معاملاتی به تلگرام"""
+        try:
+            if not signal:
+                return False
+                
+            direction_emoji = "🟢 خرید" if signal['direction'] == "خرید" else "🔴 فروش"
+            
+            # ساخت متن پیام
+            message = f"""
+⚡️ *سیگنال معاملاتی جدید* ⚡️
+
+{direction_emoji} *{signal['symbol']}*
+
+💰 قیمت ورود: `{signal['entry_price']}`
+🛑 حد ضرر: `{signal['stop_loss']}`
+✅ حد سود: `{signal['take_profit']}`
+
+⏱ مدت زمان: *{signal['duration_hours']} ساعت*
+💪 قدرت سیگنال: *{signal['strength']:.1f}%*
+
+⏰ تاریخ سیگنال: {signal['timestamp']}
+
+🤖 سیگنال‌دهی خودکار هوشمند
+            """
+            
+            # ارسال پیام متنی
+            self.bot.send_message(
+                chat_id=self.chat_id,
                 text=message,
-                parse_mode='HTML'
+                parse_mode=telegram.ParseMode.MARKDOWN
             )
-        except TelegramError as e:
-            logger.error(f"Telegram error: {str(e)}")
+            
+            # ارسال نمودار
+            chart = self.create_signal_chart(signal['symbol'])
+            if chart:
+                self.bot.send_photo(
+                    chat_id=self.chat_id,
+                    photo=chart,
+                    caption=f"نمودار تحلیلی {signal['symbol']}"
+                )
+            
+            # ذخیره سیگنال در لیست سیگنال‌های فعال
+            self.active_signals[signal['symbol']] = signal
+            
+            logger.info(f"سیگنال معاملاتی برای {signal['symbol']} با موفقیت ارسال شد.")
+            return True
+            
+        except Exception as e:
+            logger.error(f"خطا در ارسال سیگنال به تلگرام: {str(e)}")
+            return False
 
-    async def check_connection(self):
+    def send_telegram_message(self, message):
+        """ارسال پیام ساده به تلگرام"""
         try:
-            await self.exchange.fetch_balance()
-            if not self.connected:
-                await self.send_telegram("✅ اتصال به صرافی با موفقیت برقرار شد")
-                self.connected = True
+            self.bot.send_message(
+                chat_id=self.chat_id,
+                text=message
+            )
             return True
         except Exception as e:
-            if self.connected:
-                await self.send_telegram(f"⚠️ اتصال قطع شد! خطا: {str(e)}")
-                self.connected = False
+            logger.error(f"خطا در ارسال پیام به تلگرام: {str(e)}")
             return False
 
-    async def run_analysis(self):
-        if await self.check_connection():
-            symbols = config.SYMBOLS
-            batch_size = config.THROTTLING['batch_size']
-            
-            for i in range(0, len(symbols), batch_size):
-                batch = symbols[i:i+batch_size]
-                tasks = [self.analyze_symbol(symbol) for symbol in batch]
-                results = await asyncio.gather(*tasks)
-                
-                for signals in results:
-                    for signal in signals:
-                        if signal['confidence'] >= config.THRESHOLDS['min_confidence']:
-                            await self.generate_signal_message(signal)
-                
-                await asyncio.sleep(config.THROTTLING['delay_between_batches'])
-
-    async def generate_signal_message(self, signal):
-        message = (
-            f"🚨 <b>سیگنال معاملاتی!</b> 🚨\n\n"
-            f"🏷 ارز: {signal['symbol']}\n"
-            f"📊 تایم فریم: {signal['timeframe']}\n"
-            f"🔢 نوع سیگنال: {signal['signal']}\n"
-            f"📈 قیمت فعلی: {signal['price']:.4f}\n"
-            f"✅ اعتبار: {signal['confidence']}%\n"
-            f"🎯 حد سود: {signal['price'] * 1.03:.4f}\n"
-            f"🛑 حد ضرر: {signal['price'] * 0.97:.4f}\n"
-            f"⏳ مدت اعتبار: ۶ ساعت"
-        )
-        await self.send_telegram(message)
-
-    async def main(self):
-        await self.send_telegram("🤖 ربات مانیتورینگ LBank فعال شد!")
+    async def periodic_analysis(self):
+        """انجام تحلیل دوره‌ای بر روی تمام ارزها"""
         while True:
             try:
-                await self.run_analysis()
-                await asyncio.sleep(1800)
+                logger.info("شروع تحلیل دوره‌ای بازار...")
+                tasks = []
+                for symbol in self.symbols:
+                    for timeframe in self.timeframes:
+                        tasks.append(self.fetch_ohlcv_data(symbol, timeframe))
+                
+                # اجرای همزمان تمام درخواست‌ها
+                await asyncio.gather(*tasks)
+                
+                # تحلیل و تولید سیگنال برای هر ارز
+                for symbol in self.symbols:
+                    signal = self.generate_trading_signal(symbol)
+                    if signal and self.should_send_signal(signal):
+                        self.send_signal_to_telegram(signal)
+                
+                logger.info("تحلیل دوره‌ای با موفقیت انجام شد. خواب برای 5 دقیقه...")
+                await asyncio.sleep(300)  # خواب برای 5 دقیقه
+                
             except Exception as e:
-                logger.error(f"Critical error: {str(e)}")
-                await self.send_telegram(f"🔥 خطای سیستمی: {str(e)}")
-                await asyncio.sleep(60)
+                logger.error(f"خطا در تحلیل دوره‌ای: {str(e)}")
+                await asyncio.sleep(60)  # در صورت خطا 1 دقیقه صبر کنید
+
+    def start_telegram_handlers(self):
+        """شروع کردن هندلرهای تلگرام برای دریافت دستورات"""
+        updater = Updater(self.config.TELEGRAM_TOKEN, use_context=True)
+        dp = updater.dispatcher
+
+        # دستور وضعیت
+        def status(update, context):
+            status_msg = "وضعیت سیستم:\n"
+            status_msg += f"• اتصال به صرافی: {'✅' if self.is_connected else '❌'}\n"
+            status_msg += f"• تعداد ارزهای تحت نظارت: {len(self.symbols)}\n"
+            status_msg += f"• سیگنال‌های فعال: {len(self.active_signals)}"
+            update.message.reply_text(status_msg)
+
+        # دستور راهنما
+        def help(update, context):
+            help_text = """
+دستورات موجود:
+/status - نمایش وضعیت سیستم
+/analyze [symbol] - تحلیل فوری یک ارز
+/list_signals - نمایش سیگنال‌های فعال
+"""
+            update.message.reply_text(help_text)
+
+        # ثبت هندلرها
+        dp.add_handler(CommandHandler("status", status))
+        dp.add_handler(CommandHandler("help", help))
+        
+        # شروع پولینگ
+        updater.start_polling()
+        logger.info("هندلرهای تلگرام با موفقیت راه‌اندازی شدند.")
+
+    def run(self):
+        """شروع اجرای اصلی برنامه"""
+        try:
+            # شروع هندلرهای تلگرام در یک ریسمان جداگانه
+            telegram_thread = threading.Thread(target=self.start_telegram_handlers)
+            telegram_thread.daemon = True
+            telegram_thread.start()
 
-    async def close(self):
-        await self.http_client.aclose()
+            # شروع تحلیل دوره‌ای در لوپ asyncio
+            loop = asyncio.get_event_loop()
+            loop.run_until_complete(self.periodic_analysis())
+            
+        except KeyboardInterrupt:
+            logger.info("دریافت سیگنال توقف. خاموش کردن سیستم...")
+            self.send_telegram_message("🛑 سیستم در حال خاموش شدن...")
+        except Exception as e:
+            logger.error(f"خطای غیرمنتظره: {str(e)}")
+            self.send_telegram_message(f"☠️ خطای بحرانی: {str(e)}")
 
 if __name__ == "__main__":
-    monitor = LBankMonitor()
-    try:
-        asyncio.run(monitor.main())
-    except KeyboardInterrupt:
-        asyncio.run(monitor.close())
+    analyzer = CryptoAnalyzer()
+    analyzer.run()