Update app.py

app.py

@@ -1,197 +1,488 @@
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect, Request
-from fastapi.responses import HTMLResponse
-from fastapi.templating import Jinja2Templates
-from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
-import asyncio
+import os
+import sys
+import gc
+import json
 import logging
-import httpx
+import asyncio
+import traceback
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Optional, Set, List, Any
+from collections import deque
+from contextlib import asynccontextmanager
+import tempfile
+
+# تنظیمات اولیه و مسیرها
+BASE_DIR = Path(__file__).parent
+temp_cache_dir = tempfile.gettempdir()
+
+# تنظیم متغیرهای محیطی قبل از import کردن کتابخانه‌های هوش مصنوعی
+os.environ["HF_HOME"] = str(temp_cache_dir)
+if "TRANSFORMERS_CACHE" in os.environ:
+    del os.environ["TRANSFORMERS_CACHE"]
+os.environ["TRANSFORMERS_PARALLELISM"] = "false"
+os.environ["TORCH_HOME"] = str(Path(temp_cache_dir) / "torch")
+
+# کتابخانه‌های هوش مصنوعی
 import torch
+import transformers
+from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM, AutoModelForMaskedLM
 
-# Initialize FastAPI
-app = FastAPI()
-
-# Logging setup
-logging.basicConfig(level=logging.INFO)
-
-# Telegram Token and Chat ID (Replace with your actual values)
-TELEGRAM_TOKEN = "7437859619:AAGeGG3ZkLM0OVaw-Exx1uMRE55JtBCZZCY"
-CHAT_ID = "-1002228627548"
-
-# Templating setup
-templates = Jinja2Templates(directory="templates")
-
+# کتابخانه‌های وب و تلگرام
+import aiofiles
+import aiodns
+import httpx
+import uvicorn
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, Request, HTTPException, Response, Query
+from fastapi.responses import HTMLResponse, FileResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from telegram import Update, ReplyKeyboardMarkup, InlineKeyboardMarkup, InlineKeyboardButton
+from telegram.ext import Application, CommandHandler, MessageHandler, CallbackQueryHandler, ContextTypes, filters
+from telegram.error import NetworkError
+
+# کتابخانه‌های دیگر
+import hazm
+from logging.handlers import RotatingFileHandler
+from cachetools import TTLCache
+
+class AppConfig:
+    """تنظیمات اصلی برنامه"""
+
+    # تنظیمات مسیرها
+    BASE_DIR = Path("/app")
+    STATIC_DIR = BASE_DIR / "static"
+    TEMPLATES_DIR = BASE_DIR / "templates"
+    CACHE_DIR = Path(temp_cache_dir) / "cache"
+    LOG_DIR = Path(temp_cache_dir) / "logs"
+
+    # تنظیمات تلگرام
+    TELEGRAM_TOKEN = "7437859619:AAGeGG3ZkLM0OVaw-Exx1uMRE55JtBCZZCY"
+    CHAT_ID = "-1002228627548"
+    ADMIN_CHAT_ID = "1053836064"
+    ALLOWED_CHAT_IDS = {"-1002228627548", "1053836064"}
+
+    # تنظیمات مدل
+    MODEL_NAME = "HooshvareLab/bert-fa-base-uncased"
+    MAX_LENGTH = 128
+    MIN_LENGTH = 20
+    TEMPERATURE = 0.7
+    TOP_K = 50
+    TOP_P = 0.92
+
+    # تنظیمات سیستم
+    MAX_RETRIES = 3
+    CACHE_TTL = 300
+    MAX_CONNECTIONS = 5
+    MEMORY_THRESHOLD = 85
+    CLEANUP_THRESHOLD = 80
+    MAX_MESSAGE_LENGTH = 512
+    MAX_THREADS = 1
+
+    @classmethod
+    def setup_directories(cls) -> None:
+        """ایجاد دایرکتوری‌های مورد نیاز"""
+        try:
+            for path in [cls.CACHE_DIR, cls.LOG_DIR, cls.STATIC_DIR, cls.TEMPLATES_DIR]:
+                path.mkdir(exist_ok=True, parents=True)
+            logging.info("دایرکتوری‌ها با موفقیت ایجاد شدند")
+        except Exception as e:
+            logging.error(f"خطا در ایجاد دایرکتوری‌ها: {e}")
+            raise
+
+def setup_logging() -> None:
+    """راه‌اندازی سیستم لاگ"""
+    logger = logging.getLogger()
+    logger.setLevel(logging.INFO)
+
+    formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+
+    # لاگ در فایل
+    file_handler = RotatingFileHandler(
+        AppConfig.LOG_DIR / 'app.log',
+        maxBytes=10**6,
+        backupCount=5,
+        encoding='utf-8'
+    )
+    file_handler.setFormatter(formatter)
+
+    # لاگ در کنسول
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(formatter)
+
+    logger.handlers = []
+    logger.addHandler(file_handler)
+    logger.addHandler(console_handler)
+
+class AIModel:
+    """کلاس مدیریت مدل هوش مصنوعی"""
 
-# WebSocket Manager
-class WebSocketManager:
     def __init__(self):
-        self.active_connection: WebSocket = None
-
-    async def connect(self, websocket: WebSocket):
-        """Connects the WebSocket"""
-        await websocket.accept()
-        self.active_connection = websocket
-        logging.info("WebSocket connected.")
-
-    async def disconnect(self):
-        """Disconnects the WebSocket"""
-        if self.active_connection:
-            await self.active_connection.close()
-            self.active_connection = None
-            logging.info("WebSocket disconnected.")
-
-    async def send_message(self, message: str):
-        """Sends a message through WebSocket"""
-        if self.active_connection:
-            await self.active_connection.send_text(message)
-            logging.info(f"Sent via WebSocket: {message}")
-
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model = None
+        self.tokenizer = None
+        self.pipeline = None
+        self._initialize_model()
+
+    def _initialize_model(self):
+        try:
+            logging.info(f"در حال بارگذاری مدل {AppConfig.MODEL_NAME}...")
+
+            # بارگذاری توکنایزر
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                AppConfig.MODEL_NAME,
+                cache_dir=AppConfig.CACHE_DIR,
+                use_fast=True
+            )
+
+            # بارگذاری مدل
+            self.model = AutoModelForMaskedLM.from_pretrained(
+                AppConfig.MODEL_NAME,
+                cache_dir=AppConfig.CACHE_DIR,
+                torch_dtype=torch.float32,
+                low_cpu_mem_usage=True,
+                device_map="auto" if torch.cuda.is_available() else None
+            )
+
+            # ایجاد پایپلاین
+            self.pipeline = pipeline(
+                "fill-mask",
+                model=self.model,
+                tokenizer=self.tokenizer,
+                device=0 if torch.cuda.is_available() else -1
+            )
+
+            logging.info("مدل با موفقیت بارگذاری شد")
+            return True
+        except Exception as e:
+            logging.error(f"خطا در بارگذاری مدل: {e}")
+            return False
+
+    async def generate_response(self, text: str) -> str:
+        try:
+            # اضافه کردن توکن ماسک اگر وجود نداشته باشد
+            if "[MASK]" not in text:
+                if len(text.split()) > 3:
+                    words = text.split()
+                    words.insert(3, "[MASK]")
+                    text = " ".join(words)
+                else:
+                    text = text + " [MASK]"
+
+            # تولید پاسخ
+            result = self.pipeline(text)
+            response = result[0]["sequence"]
+
+            # پاکسازی پاسخ
+            response = response.replace("[MASK]", "").strip()
+            if response.startswith(text):
+                response = response[len(text):].strip()
+
+            return response
+
+        except Exception as e:
+            logging.error(f"خطا در تولید پاسخ: {e}")
+            return "متأسفم، در تولید پاسخ مشکلی پیش آمد."
+
+class TelegramUI:
+    """کلاس مدیریت رابط کاربری تلگرام"""
+
+    @staticmethod
+    def get_main_menu() -> InlineKeyboardMarkup:
+        """ایجاد منوی اصلی"""
+        keyboard = [
+            [
+                InlineKeyboardButton("💬 چت جدید", callback_data="new_chat"),
+                InlineKeyboardButton("🔍 جستجو", callback_data="search")
+            ],
+            [
+                InlineKeyboardButton("📚 آموزش", callback_data="learn"),
+                InlineKeyboardButton("🎯 تمرین", callback_data="practice")
+            ],
+            [
+                InlineKeyboardButton("⚙️ تنظیمات", callback_data="settings"),
+                InlineKeyboardButton("❓ راهنما", callback_data="help")
+            ]
+        ]
+        return InlineKeyboardMarkup(keyboard)
+
+    @staticmethod
+    def get_chat_keyboard() -> ReplyKeyboardMarkup:
+        """ایجاد صفحه کلید چت"""
+        keyboard = [
+            ["💭 چت عمومی", "❓ سوال و جواب"],
+            ["📚 آموزش", "🎯 تمرین"],
+            ["🏠 منوی اصلی"]
+        ]
+        return ReplyKeyboardMarkup(keyboard, resize_keyboard=True)
+
+class TelegramBot:
+    """کلاس اصلی ربات تلگرام"""
+
+    def __init__(self, ai_model: AIModel):
+        self.model = ai_model
+        self.ui = TelegramUI()
+        self.application = Application.builder().token(AppConfig.TELEGRAM_TOKEN).build()
+        self._setup_handlers()
+        self.normalizer = hazm.Normalizer()
+
+    def _setup_handlers(self):
+        """تنظیم هندلرهای ربات"""
+        self.application.add_handler(CommandHandler("start", self.start_command))
+        self.application.add_handler(CallbackQueryHandler(self.button_callback))
+        self.application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, self.handle_message))
+
+    async def start_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
+        """پردازش دستور شروع"""
+        welcome_text = """
+🌟 به دستیار هوشمند خوش آمدید!
+
+من می‌توانم در موارد زیر به شما کمک کنم:
+• پاسخ به سؤالات
+• آموزش مطالب
+• حل تمرین
+• جستجو در منابع
+
+لطفاً یکی از گزینه‌های زیر را انتخاب کنید:
+"""
+        await update.message.reply_text(
+            welcome_text,
+            reply_markup=self.ui.get_main_menu()
+        )
 
-websocket_manager = WebSocketManager()
+    async def button_callback(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
+        """پردازش دکمه‌های منو"""
+        query = update.callback_query
+        await query.answer()
+
+        if query.data == "new_chat":
+            await query.message.reply_text(
+                "💭 نوع چت را انتخاب کنید:",
+                reply_markup=self.ui.get_chat_keyboard()
+            )
+        elif query.data == "help":
+            help_text = """
+📚 راهنمای استفاده:
+
+1️⃣ برای شروع گفتگو، از دکمه "چت جدید" استفاده کنید
+2️⃣ نوع گفتگو را انتخاب کنید
+3️⃣ سؤال یا پیام خود را ارسال کنید
+4️⃣ منتظر پاسخ بمانید
+
+❗️ نکات مهم:
+• سؤالات خود را واضح و دقیق مطرح کنید
+• از منوی تنظیمات برای شخصی‌سازی استفاده کنید
+• برای بازگشت به منوی اصلی از دکمه "🏠 منوی اصلی" استفاده کنید
+"""
+            await query.message.edit_text(help_text, reply_markup=self.ui.get_main_menu())
+
+    async def handle_message(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
+        """پردازش پیام‌های دریافتی"""
+        if update.message.text == "🏠 منوی اصلی":
+            await self.start_command(update, context)
+            return
+
+        try:
+            # نرمال‌سازی متن
+            normalized_text = self.normalizer.normalize(update.message.text)
+            # تولید پاسخ
+            response = await self.model.generate_response(normalized_text)
+            await update.message.reply_text(f"🤖 {response}")
+        except Exception as e:
+            logging.error(f"خطا در پردازش پیام: {e}")
+            await update.message.reply_text(
+                "متأسفانه خطایی رخ داد. لطفاً دوباره تلاش کنید."
+            )
+
+    async def run(self):
+        """اجرای ربات"""
+        try:
+            await self.application.run_polling()
+        except Exception as e:
+            logging.error(f"خطا در اجرای ربات: {e}")
+            raise
+
+# ایجاد برنامه FastAPI
+app = FastAPI(title="AI Assistant")
+
+# پیوست کردن فایل‌های استاتیک
+app.mount("/static", StaticFiles(directory=AppConfig.STATIC_DIR), name="static")
+templates = Jinja2Templates(directory=AppConfig.TEMPLATES_DIR)
+
+# HTML پیش‌فرض
+DEFAULT_HTML = """
+<!DOCTYPE html>
+<html dir="rtl" lang="fa">
+<head>
+    <meta charset="UTF-8">
+    <title>دستیار هوشمند</title>
+    <style>
+        body {
+            font-family: Tahoma, Arial;
+            background-color: #f5f5f5;
+            margin: 0;
+            padding: 20px;
+        }
+        .container {
+            max-width: 800px;
+            margin: 0 auto;
+            background: white;
+            padding: 20px;
+            border-radius: 10px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        h1 { color: #1a73e8; }
+        .status { margin: 20px 0; }
+        .chat-container {
+            margin-top: 20px;
+            border: 1px solid #e0e0e0;
+            border-radius: 8px;
+            padding: 10px;
+            min-height: 300px;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>دستیار هوشمند</h1>
+        <div class="status">
+            <p>برای استفاده از دستیار هوشمصنوعی، به ربات تلگرام مراجعه کنید یا از رابط وب استفاده نمایید.</p>
+        </div>
+        <div class="chat-container" id="chat-container">
+            <!-- Messages will appear here -->
+        </div>
+        <input type="text" id="message-input" placeholder="پیام خود را بنویسید..." style="width: 100%; padding: 10px; margin-top: 10px;">
+        <button onclick="sendMessage()" style="margin-top: 10px; padding: 10px 20px;">ارسال</button>
+    </div>
+    <script>
+        const ws = new WebSocket(`ws://${window.location.host}/ws`);
+        const chatContainer = document.getElementById('chat-container');
+        const messageInput = document.getElementById('message-input');
+
+        ws.onmessage = function(event) {
+            const response = JSON.parse(event.data);
+            appendMessage('bot', response.response);
+        };
+
+        function appendMessage(type, text) {
+            const messageDiv = document.createElement('div');
+            messageDiv.style.padding = '10px';
+            messageDiv.style.margin = '5px';
+            messageDiv.style.borderRadius = '5px';
+
+            if (type === 'user') {
+                messageDiv.style.backgroundColor = '#e3f2fd';
+                messageDiv.style.marginLeft = '20%';
+            } else {
+                messageDiv.style.backgroundColor = '#f5f5f5';
+                messageDiv.style.marginRight = '20%';
+            }
 
+            messageDiv.textContent = text;
+            chatContainer.appendChild(messageDiv);
+            chatContainer.scrollTop = chatContainer.scrollHeight;
+        }
 
-# BLOOM Model Manager
-class BloomAI:
-    def __init__(self):
-        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        self.pipeline = None
+        function sendMessage() {
+            const message = messageInput.value.trim();
+            if (message) {
+                appendMessage('user', message);
+                ws.send(message);
+                messageInput.value = '';
+            }
+        }
 
-    def load_model(self):
-        """Loads BLOOM AI Model"""
-        logging.info("Loading BLOOM model...")
-        tokenizer = AutoTokenizer.from_pretrained("bigscience/bloom-560m")
-        model = AutoModelForCausalLM.from_pretrained("bigscience/bloom-560m")
-        self.pipeline = pipeline(
-            "text-generation",
-            model=model,
-            tokenizer=tokenizer,
-            device=0 if torch.cuda.is_available() else -1
-        )
-        logging.info("BLOOM model loaded successfully.")
-
-    async def generate_response(self, prompt: str) -> str:
-        """Generates a response using BLOOM"""
-        if not prompt.strip():
-            return "⚠️ Please send a valid message."
-        logging.info(f"Generating response for prompt: {prompt}")
-        outputs = self.pipeline(
-            prompt,
-            max_length=100,
-            do_sample=True,
-            temperature=0.7,
-            top_k=50,
-            top_p=0.9,
-            num_return_sequences=1,
-            no_repeat_ngram_size=2
+        messageInput.addEventListener('keypress', function(e) {
+            if (e.key === 'Enter') {
+                sendMessage();
+            }
+        });
+    </script>
+</body>
+</html>
+"""
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """مدیریت چرخه حیات برنامه"""
+    # راه‌اندازی
+    AppConfig.setup_directories()
+    setup_logging()
+
+    # ایجاد نمونه از مدل هوش مصنوعی
+    app.state.model = AIModel()
+    app.state.is_ready = asyncio.Event()
+
+    # راه‌اندازی ربات تلگرام
+    app.state.bot = TelegramBot(app.state.model)
+    asyncio.create_task(app.state.bot.run())
+
+    yield
+
+    # خاتمه
+    tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]
+    for task in tasks:
+        task.cancel()
+    await asyncio.gather(*tasks, return_exceptions=True)
+    logging.info("برنامه با موفقیت خاتمه یافت")
+
+@app.get("/", response_class=HTMLResponse)
+async def home(request: Request):
+    """صفحه اصلی"""
+    try:
+        return templates.TemplateResponse(
+            "index.html",
+            {
+                "request": request,
+                "bot_status": "فعال" if request.app.state.is_ready.is_set() else "در حال آماده‌سازی"
+            }
         )
-        response = outputs[0]["generated_text"]
-        return response.strip()
-
-
-# Initialize BLOOM
-bloom_ai = BloomAI()
-bloom_ai.load_model()
-
-
-# Telegram Message Handling
-async def send_telegram_message(text: str):
-    """Sends a message to Telegram"""
-    async with httpx.AsyncClient() as client:
-        url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendMessage"
-        payload = {"chat_id": CHAT_ID, "text": text}
-        response = await client.post(url, json=payload)
-        if response.status_code == 200:
-            logging.info(f"Sent to Telegram: {text}")
-        else:
-            logging.error(f"Failed to send message to Telegram: {response.text}")
-
-
-@app.post("/telegram")
-async def telegram_webhook(update: dict):
-    """Handles Telegram Webhook messages"""
-    if "message" in update:
-        chat_id = str(update["message"]["chat"]["id"])
-        if chat_id != CHAT_ID:
-            return {"status": "Unauthorized"}
-        
-        user_message = update["message"]["text"]
-        logging.info(f"Received from Telegram: {user_message}")
-        
-        # Process the message
-        response = await bloom_ai.generate_response(user_message)
-        await send_telegram_message(response)
-    return {"status": "ok"}
-
-
-# WebSocket Endpoint
+    except Exception as e:
+        logging.error(f"خطا در نمایش صفحه اصلی: {e}")
+        return HTMLResponse(content=DEFAULT_HTML)
+
 @app.websocket("/ws")
 async def websocket_endpoint(websocket: WebSocket):
-    """WebSocket communication for real-time interaction"""
-    await websocket_manager.connect(websocket)
+    """اتصال WebSocket"""
+    await websocket.accept()
+
     try:
         while True:
-            # Receive message from WebSocket
-            data = await websocket.receive_text()
-            logging.info(f"Received from WebSocket: {data}")
-            
-            # Process the message
-            response = await bloom_ai.generate_response(data)
-            
-            # Send response back through WebSocket
-            await websocket_manager.send_message(response)
-    except WebSocketDisconnect:
-        # Handle WebSocket disconnection
-        await websocket_manager.disconnect()
-
-
-# HTML Test UI
-@app.get("/")
-async def get_ui(request: Request):
-    """Displays the WebSocket HTML UI"""
-    return templates.TemplateResponse("index.html", {"request": request})
-
-
-# Simple UI (fallback in case templates folder is not available)
-@app.get("/simple-ui")
-async def simple_ui():
-    """Fallback HTML for WebSocket Test"""
-    return HTMLResponse(content="""
-    <!DOCTYPE html>
-    <html>
-    <head>
-        <title>WebSocket Test</title>
-        <script>
-            let ws = new WebSocket("ws://localhost:8000/ws");
-
-            ws.onopen = () => {
-                console.log("WebSocket connection opened.");
-            };
-
-            ws.onmessage = (event) => {
-                console.log("Message from server:", event.data);
-                const msgContainer = document.getElementById("messages");
-                const msg = document.createElement("div");
-                msg.innerText = event.data;
-                msgContainer.appendChild(msg);
-            };
-
-            ws.onclose = () => {
-                console.log("WebSocket connection closed.");
-            };
-
-            function sendMessage() {
-                const input = document.getElementById("messageInput");
-                const message = input.value;
-                ws.send(message);
-                input.value = "";
-            }
-        </script>
-    </head>
-    <body>
-        <h1>WebSocket Test</h1>
-        <div id="messages" style="border: 1px solid black; height: 200px; overflow-y: scroll;"></div>
-        <input id="messageInput" type="text" />
-        <button onclick="sendMessage()">Send</button>
-    </body>
-    </html>
-    """)
+            # دریافت پیام
+            text = await websocket.receive_text()
 
+            # تولید پاسخ
+            response = await app.state.model.generate_response(text)
+
+            # ارسال پاسخ
+            await websocket.send_json({
+                "response": response
+            })
+    except WebSocketDisconnect:
+        logging.info("اتصال WebSocket قطع شد")
+    except Exception as e:
+        logging.error(f"خطا در WebSocket: {e}")
+        await websocket.close()
+
+@app.exception_handler(404)
+async def not_found_handler(request: Request, exc: Exception):
+    """پردازش خطای 404"""
+    return HTMLResponse(content=DEFAULT_HTML, status_code=404)
+
+@app.exception_handler(500)
+async def server_error_handler(request: Request, exc: Exception):
+    """پردازش خطای 500"""
+    return HTMLResponse(content=DEFAULT_HTML, status_code=500)
+
+if __name__ == "__main__":
+    # اجرای برنامه
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=7860,
+        reload=False,
+        workers=1,
+        log_level="info"
+    )