Update app.py

app.py

@@ -11,18 +11,40 @@ from flask import Flask, render_template, request, Response, stream_with_context
 import requests
 import docx
 
-# ================== تنظیمات لاگ ==================
-# فقط خطاهای حیاتی را لاگ میکنیم تا کنسول شلوغ نشود
-logging.basicConfig(level=logging.ERROR, format='%(asctime)s - %(levelname)s - %(message)s')
+# ================== بخش تنظیمات لاگ‌نویسی ==================
+
+class NoGrpcFilter(logging.Filter):
+    def filter(self, record):
+        return not record.getMessage().startswith('ALTS creds ignored.')
+
+def setup_logging():
+    log_format = '[%(asctime)s] [%(levelname)s]: %(message)s'
+    date_format = '%Y-%m-%d %H:%M:%S'
+    formatter = logging.Formatter(log_format, datefmt=date_format)
+    
+    root_logger = logging.getLogger()
+    if root_logger.hasHandlers():
+        root_logger.handlers.clear()
+    
+    console_handler = logging.StreamHandler()
+    console_handler.setFormatter(formatter)
+    console_handler.addFilter(NoGrpcFilter())
+
+    root_logger.addHandler(console_handler)
+    root_logger.setLevel(logging.INFO)
+
+setup_logging()
 app = Flask(__name__)
 
-# ================== تنظیمات کلیدها ==================
+# ================== بخش پیکربندی Gemini ==================
 
 GEMINI_MODEL_NAME = "gemini-2.5-flash" 
 ALL_KEYS_STR = os.environ.get("ALL_GEMINI_API_KEYS", "")
-# تمیز کردن کلیدها
 GEMINI_API_KEYS = [key.strip() for key in ALL_KEYS_STR.split(',') if key.strip()]
 
+if not GEMINI_API_KEYS:
+    logging.critical("هشدار: هیچ کلید API برای Gemini در Secrets تنظیم نشده است! (ALL_GEMINI_API_KEYS)")
+
 key_index_counter = 0
 key_lock = threading.Lock()
 
@@ -36,7 +58,7 @@ def get_next_key_with_index():
         key_index_counter = (key_index_counter + 1) % len(GEMINI_API_KEYS)
         return key, current_index
 
-# ================== مسیرها ==================
+# ================== پایان بخش پیکربندی ====================
 
 @app.route('/')
 def index():
@@ -44,37 +66,46 @@ def index():
 
 @app.route('/chat', methods=['POST'])
 def chat():
-    # اگر کلا کلیدی نباشد، باز هم نباید کرش کنیم
+    # اگر کلیدی تعریف نشده باشد، به جای ارور، یک پیام متنی معمولی میفرستیم
     if not GEMINI_API_KEYS:
-        # شبیه سازی پاسخ متنی ربات به جای ارور سیستمی
-        fake_response = {"choices": [{"delta": {"content": "⚠️ تنظیمات سیستم کامل نیست (کلید API یافت نشد)."}}]}
+        fake_response = {"choices": [{"delta": {"content": "⚠️ تنظیمات سرور کامل نیست (کلید API یافت نشد)."}}]}
         return Response(f"data: {json.dumps(fake_response)}\n\n", mimetype='text/event-stream')
 
     data = request.json
-    system_instruction = "تو چت بات هوش مصنوعی آلفا هستی. دوستانه، کوتاه و با ایموجی پاسخ بده."
+    system_instruction = "تو چت بات هوش مصنوعی آلفا هستی و توسط برنامه هوش مصنوعی آلفا توسعه داده شدی. کمی با کاربران باحال و دوستانه صحبت کن و از ایموجی‌ها استفاده کن. همیشه پاسخ‌هایت را به زبان فارسی و یا هر زبانی که کاربر صحبت میکنه ارائه بده."
+    
     show_thoughts = data.get("show_thoughts", False)
 
-    # --- پردازش پیام‌ها و فایل‌ها ---
+    # === بخش پردازش پیام‌ها و فایل DOCX (بدون تغییر) ===
     gemini_messages = []
     for msg in data.get("messages", []):
         role = "model" if msg.get("role") == "assistant" else msg.get("role")
+        
         processed_parts = []
         for part in msg.get("parts", []):
             if part.get("text"):
                 processed_parts.append({"text": part["text"]})
+            
             if part.get("base64Data") and part.get("mimeType"):
                 mime_type = part["mimeType"]
-                # هندل کردن فایل Word
+                
                 if mime_type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
                     try:
-                        decoded = base64.b64decode(part["base64Data"])
-                        doc = docx.Document(io.BytesIO(decoded))
-                        text = "\n".join([p.text for p in doc.paragraphs])
-                        processed_parts.append({"text": f"محتوای فایل کاربر:\n{text}"})
-                    except:
-                        processed_parts.append({"text": "(فایل Word قابل خواندن نبود)"})
+                        decoded_data = base64.b64decode(part["base64Data"])
+                        file_stream = io.BytesIO(decoded_data)
+                        document = docx.Document(file_stream)
+                        full_text = "\n".join([para.text for para in document.paragraphs])
+                        
+                        final_text_part = f"کاربر یک فایل Word آپلود کرد. محتوای متنی آن به شرح زیر است:\n\n---\n\n{full_text}\n\n---"
+                        processed_parts.append({"text": final_text_part})
+                        logging.info("فایل DOCX با موفقیت پردازش و متن آن استخراج شد.")
+
+                    except Exception as e:
+                        logging.error(f"خطا در پردازش فایل DOCX: {e}")
+                        processed_parts.append({"text": "[خطا: امکان پردازش فایل Word وجود نداشت.]"})
+                
                 else:
-                    processed_parts.append({"inline_data": {"mime_type": mime_type, "data": part["base64Data"]}})
+                    processed_parts.append({"inline_data": {"mime_type": part["mimeType"], "data": part["base64Data"]}})
         
         if processed_parts:
             if gemini_messages and gemini_messages[-1]["role"] == role:
@@ -82,105 +113,120 @@ def chat():
             else:
                 gemini_messages.append({"role": role, "parts": processed_parts})
 
-    # اگر پیامی نبود تمام کن
     if not any(msg['role'] == 'user' for msg in gemini_messages):
         return Response("data: [DONE]\n\n", mimetype='text/event-stream')
-
-    # --- تابع اصلی استریم با مدیریت خطای پیشرفته ---
+        
+    # === تابع اصلی استریم با مکانیزم تلاش مجدد مخفی ===
     @stream_with_context
-    def stream_response_generator():
-        # تعداد دفعاتی که کلا تلاش میکنیم (مثلا 3 دور کامل روی همه کلیدها)
-        # این باعث میشه کاربر احساس نکنه سرور قطع شده، فقط فکر میکنه داره فکر میکنه
-        MAX_GLOBAL_RETRIES = len(GEMINI_API_KEYS) * 3 if len(GEMINI_API_KEYS) > 0 else 1
+    def stream_response():
+        # تعداد کلیدها را میگیریم
+        num_keys = len(GEMINI_API_KEYS)
+        # تعداد تلاش‌ها: حداقل 3 برابر تعداد کلیدها تلاش میکنیم تا مطمئن شویم
+        max_attempts = max(num_keys * 3, 5) 
         
-        # فلگ برای اینکه بفهمیم بالاخره موفق شدیم یا نه
-        success = False
+        success_flag = False
 
-        for attempt in range(MAX_GLOBAL_RETRIES):
+        for attempt in range(max_attempts):
             try:
-                api_key, idx = get_next_key_with_index()
+                api_key, key_index = get_next_key_with_index()
+                # اگر کلیدی نبود (خیلی بعید)
+                if not api_key: break
+
+                logging.info(f"تلاش شماره {attempt + 1} با کلید ایندکس {key_index}...")
+
+                api_endpoint = f"https://generativelanguage.googleapis.com/v1beta/models/{GEMINI_MODEL_NAME}:streamGenerateContent?key={api_key}&alt=sse"
                 
-                # تنظیمات تایم اوت:
-                # 5 ثانیه برای اتصال (اگر کلید خراب بود سریع رد شو)
-                # 100 ثانیه برای خواندن (اگر فایل سنگین بود صبر کن)
+                payload = {
+                    "contents": gemini_messages,
+                    "systemInstruction": {"parts": [{"text": system_instruction}]},
+                    "tools": [{"google_search": {}}],
+                    "generationConfig": {
+                        "temperature": 0.7,
+                    }
+                }
+                
+                if show_thoughts:
+                    payload["generationConfig"]["thinking_config"] = {
+                        "include_thoughts": True
+                    }
+
+                # *** تنظیمات Timeout بسیار مهم ***
+                # Connect (5): زمان وصل شدن به گوگل. اگر 5 ثانیه طول کشید یعنی شبکه خرابه یا کلید گیر کرده -> سریع قطع کن برو بعدی
+                # Read (120): زمان انتظار برای جواب. چون فایل داری، باید زیاد باشه (120 ثانیه) تا وسط پردازش قطع نکنه.
                 response = requests.post(
-                    f"https://generativelanguage.googleapis.com/v1beta/models/{GEMINI_MODEL_NAME}:streamGenerateContent?key={api_key}&alt=sse",
-                    json={
-                        "contents": gemini_messages,
-                        "systemInstruction": {"parts": [{"text": system_instruction}]},
-                        "generationConfig": {
-                            "temperature": 0.7,
-                            "thinking_config": {"include_thoughts": True} if show_thoughts else {}
-                        }
-                    },
-                    stream=True,
-                    timeout=(5, 100) 
+                    api_endpoint, 
+                    json=payload, 
+                    stream=True, 
+                    timeout=(5, 120) 
                 )
-
-                # اگر کد 200 نبود، یعنی این کلید مشکل داره.
-                # نکته مهم: اینجا هیچ چیزی به کاربر نمیفرستیم. `continue` میکنیم تا بره کلید بعدی.
+                
+                # اگر کد وضعیت 200 نبود (یعنی 429، 500، 403 و...)
                 if response.status_code != 200:
+                    logging.warning(f"کلید {key_index} پاسخ نداد (کد {response.status_code}). تلاش بعدی...")
                     response.close()
-                    continue 
+                    continue # بدون هیچ حرفی برو سراغ کلید بعدی (کاربر چیزی نمیفهمه)
 
-                # حالا چک میکنیم که آیا واقعا دیتایی میاد؟
-                # این خط iterator رو میگیره اما هنوز دانلود نکرده
-                line_iter = response.iter_lines()
-                
-                # سعی میکنیم اولین خط رو بگیریم.
-                # اگر اینجا ارور بده (مثل 502 وسط کار)، میره توی except و کلید بعدی رو تست میکنه
-                # پس کاربر هنوز چیزی ندیده.
-                first_chunk_found = False
+                # اگر کد 200 بود، حالا چک میکنیم استریم دیتا داره یا نه
+                line_iterator = response.iter_lines()
                 
-                for line in line_iter:
+                # یک متغیر برای اینکه بفهمیم آیا واقعا دیتایی فرستادیم یا نه
+                data_sent_in_this_attempt = False
+
+                for line in line_iterator:
                     if line:
                         decoded_line = line.decode('utf-8')
                         if decoded_line.startswith('data: '):
                             try:
-                                json_data = json.loads(decoded_line[6:])
-                                # اگر جیسون ولید بود، یعنی اتصال درسته.
-                                # حالا شروع میکنیم به فرستادن به کاربر
-                                first_chunk_found = True
-                                
-                                # اینجا دیگه تسلیم میشیم و شروع میکنیم به ارسال به کلاینت
-                                # چون مطمئن شدیم این کلید سالمه
-                                success = True
+                                chunk_data = json.loads(decoded_line[6:])
+                                parts = chunk_data.get("candidates", [{}])[0].get("content", {}).get("parts", [])
                                 
-                                # پردازش معمولی
-                                parts = json_data.get("candidates", [{}])[0].get("content", {}).get("parts", [])
                                 for part in parts:
-                                    if part.get("text"):
-                                        is_thought = part.get("thought") is True
-                                        if show_thoughts and is_thought:
-                                            yield f"data: {json.dumps({'type': 'thought', 'content': part['text']})}\n\n"
-                                        elif not is_thought:
-                                            yield f"data: {json.dumps({'choices': [{'delta': {'content': part['text']}}]})}\n\n"
-                                            
-                            except:
-                                pass # ایگنور کردن خطاهای جزئی جیسون
-
-                # اگر حلقه تمام شد و ما دیتایی فرستادیم، یعنی کار تمامه
-                if success:
-                    return # خروج از کل تابع (پایان استریم)
+                                    if "text" not in part or not part["text"]:
+                                        continue
+                                    
+                                    # به محض اینکه اولین داده سالم رسید، یعنی موفق شدیم
+                                    data_sent_in_this_attempt = True
+                                    success_flag = True
+                                    
+                                    is_a_thought = part.get("thought") is True
+                                    if show_thoughts and is_a_thought:
+                                        thought_payload = {"type": "thought", "content": part["text"]}
+                                        yield f"data: {json.dumps(thought_payload)}\n\n"
+                                    elif not is_a_thought:
+                                        sse_payload = {"choices": [{"delta": {"content": part["text"]}}]}
+                                        yield f"data: {json.dumps(sse_payload)}\n\n"
+                                        
+                            except (json.JSONDecodeError, IndexError, KeyError):
+                                continue
+                
+                # اگر حلقه تمام شد و ما دیتایی فرستاده بودیم، یعنی کار تمام است و موفق بودیم
+                if success_flag:
+                    return # خروج کامل
 
+            # مدیریت تمام خطاها (Timeout, ConnectionError, ...)
             except Exception as e:
-                # هر خطایی (قطع نت، تایم اوت، ارور گوگل)
-                # فقط لاگ کن و برو کلید بعدی
-                # کاربر چیزی حس نمیکنه، فقط اسپینر میچرخه
-                logging.error(f"Retry {attempt}: {e}")
-                time.sleep(0.2) # وقفه کوتاه
-                continue
-
-        # === اگر به اینجا رسیدیم یعنی تمام کلیدها تست شدند و هیچکدام کار نکردند ===
-        # به جای اینکه ارور قرمز بفرستیم، یک متن معمولی میفرستیم
-        # این باعث میشه کاربر فکر کنه ربات جواب داده ولی نتونسته
-        if not success:
-            fallback_msg = "🤔 سیستم کمی شلوغ است و نتوانستم پاسخ را کامل کنم. لطفاً دوباره تلاش کنید یا فایلتان را بررسی کنید."
-            yield f"data: {json.dumps({'choices': [{'delta': {'content': fallback_msg}}]})}\n\n"
-
-    return Response(stream_response_generator(), mimetype='text/event-stream')
+                logging.error(f"خطای داخلی در تلاش {attempt+1}: {e}")
+                # اینجا یک وقفه کوتاه 0.5 ثانیه‌ای میدهیم که CPU درگیر نشود و سریع میریم کلید بعدی
+                time.sleep(0.5)
+                continue # برو تلاش بعدی (بدون اینکه به کاربر ارور بدی)
+
+        # === بخش نهایی (فقط اگر همه تلاش‌ها شکست خورد) ===
+        # اگر بعد از مثلا 30 بار تلاش (بسته به تعداد کلید) هیچکدام کار نکرد:
+        # به جای ارسال Error Payload که باعث نمایش خطای قرمز میشه،
+        # یک پیام متنی معمولی از طرف ربات میفرستیم.
+        if not success_flag:
+            logging.critical("تمام کلیدها ناموفق بودند.")
+            fallback_message = "متاسفانه شبکه من کمی کند شده و نتوانستم پاسخ را دریافت کنم. لطفاً دوباره دکمه ارسال را بزنید 🔄"
+            # فرمت پیام دقیقا مثل پاسخ عادی ربات است
+            fallback_payload = {"choices": [{"delta": {"content": fallback_message}}]}
+            yield f"data: {json.dumps(fallback_payload)}\n\n"
+
+    # استفاده از stream_with_context برای حفظ کانتکست درخواست در طول حلقه طولانی
+    return Response(stream_response(), mimetype='text/event-stream')
 
 if __name__ == '__main__':
+    if GEMINI_API_KEYS:
+        logging.info(f"سیستم در حالت توسعه شروع به کار کرد. تعداد {len(GEMINI_API_KEYS)} کلید شناسایی شد.")
     app.run(debug=True, host='0.0.0.0', port=os.environ.get("PORT", 7860))
 
 # --- END OF FILE app.py ---