Update app.py

app.py

@@ -11,17 +11,22 @@ import json
 from datetime import datetime, timedelta
 import threading
 import hashlib
+from fastapi import FastAPI
+from fastapi.responses import JSONResponse
 
 warnings.filterwarnings("ignore")
 
-# ذخیره‌سازی نتایج برای جلوگیری از مشکل session
+# ذخیره‌سازی نتایج
 results_cache = {}
 cache_lock = threading.Lock()
 
-# تابع برای پاکسازی cache قدیمی (بیش از 24 ساعت)
+# FastAPI instance برای API endpoints
+app = FastAPI()
+
+# تابع برای پاکسازی cache قدیمی
 def cleanup_old_cache():
     while True:
-        time.sleep(3600)  # هر ساعت چک کن
+        time.sleep(3600)  # هر ساعت
         with cache_lock:
             current_time = datetime.now()
             keys_to_remove = []
@@ -33,24 +38,20 @@ def cleanup_old_cache():
             if keys_to_remove:
                 print(f"[CACHE] {len(keys_to_remove)} نتیجه قدیمی پاک شد.")
 
-# شروع thread پاکسازی
 cleanup_thread = threading.Thread(target=cleanup_old_cache, daemon=True)
 cleanup_thread.start()
 
 def get_cache_key(video_url, language):
-    """ایجاد کلید یکتا برای cache بر اساس URL و زبان"""
+    """ایجاد کلید یکتا برای cache"""
     return hashlib.md5(f"{video_url}_{language}".encode()).hexdigest()
 
-def save_result_to_cache(video_url, language, mp3_path, text, status_msg):
+def save_result_to_cache(cache_key, video_url, language, mp3_path, text, status_msg, processing=False):
     """ذخیره نتیجه در cache"""
-    cache_key = get_cache_key(video_url, language)
-    
     # کپی فایل MP3 به مکان دائمی
+    cache_mp3_path = None
     if mp3_path and os.path.exists(mp3_path):
         cache_mp3_path = f"cache_{cache_key}.mp3"
         shutil.copy2(mp3_path, cache_mp3_path)
-    else:
-        cache_mp3_path = None
     
     with cache_lock:
         results_cache[cache_key] = {
@@ -59,11 +60,12 @@ def save_result_to_cache(video_url, language, mp3_path, text, status_msg):
             'text': text,
             'status_msg': status_msg,
             'video_url': video_url,
-            'language': language
+            'language': language,
+            'processing': processing,
+            'completed': not processing and (text is not None or status_msg.startswith("خطا"))
         }
     
-    print(f"[CACHE] نتیجه ذخیره شد: {cache_key}")
-    return cache_key
+    print(f"[CACHE] نتیجه ذخیره شد: {cache_key} (processing: {processing})")
 
 def get_result_from_cache(cache_key):
     """دریافت نتیجه از cache"""
@@ -71,28 +73,53 @@ def get_result_from_cache(cache_key):
         if cache_key in results_cache:
             result = results_cache[cache_key]
             print(f"[CACHE] نتیجه یافت شد: {cache_key}")
-            return result['mp3_path'], result['text'], result['status_msg']
-    return None, None, None
+            return result
+    return None
 
-def convert_to_mp3_and_transcribe(video_url, language, use_cache=True):
-    """
-    دانلود ویدیو/صوت از لینک، تبدیل به MP3، و استخراج متن با Google Speech Recognition.
-    """
+def convert_to_mp3_and_transcribe_wrapper(video_url, language):
+    """Wrapper function که cache_key را در ابتدا برمی‌گرداند"""
     if not video_url:
         return None, None, "لینک ویدیو را وارد کنید.", None
     
-    # چک کردن cache
+    # ایجاد cache key
     cache_key = get_cache_key(video_url, language)
-    if use_cache:
-        cached_mp3, cached_text, cached_status = get_result_from_cache(cache_key)
-        if cached_mp3 is not None or cached_text is not None:
-            return cached_mp3, cached_text, f"[از حافظه] {cached_status}", cache_key
     
+    # چک کردن cache
+    cached_result = get_result_from_cache(cache_key)
+    if cached_result and cached_result['completed']:
+        return (cached_result['mp3_path'], 
+                cached_result['text'], 
+                f"[از حافظه] {cached_result['status_msg']}", 
+                cache_key)
+    
+    # اگر در حال پردازش است
+    if cached_result and cached_result['processing']:
+        return None, None, "در حال پردازش... لطفاً صبر کنید.", cache_key
+    
+    # ثبت شروع پردازش
+    save_result_to_cache(cache_key, video_url, language, None, None, "در حال پردازش...", processing=True)
+    
+    # پردازش در background
+    def process_async():
+        try:
+            mp3_path, text, status_msg = convert_to_mp3_and_transcribe(video_url, language)
+            save_result_to_cache(cache_key, video_url, language, mp3_path, text, status_msg, processing=False)
+        except Exception as e:
+            save_result_to_cache(cache_key, video_url, language, None, None, f"خطا: {str(e)}", processing=False)
+    
+    # شروع پردازش (برای سادگی، همینجا انجام می‌ده��م - در production باید async باشد)
+    mp3_path, text, status_msg = convert_to_mp3_and_transcribe(video_url, language)
+    save_result_to_cache(cache_key, video_url, language, mp3_path, text, status_msg, processing=False)
+    
+    return mp3_path, text, status_msg, cache_key
+
+def convert_to_mp3_and_transcribe(video_url, language):
+    """تابع اصلی پردازش (بدون cache)"""
     progress = gr.Progress(track_tqdm=False)
     
     try:
         print(f"[DEBUG] شروع پردازش لینک: {video_url} (زبان: {language})")
-    
+        
         progress(0, desc="شروع دانلود...")
         
         # دانلود و تبدیل به MP3
@@ -120,10 +147,7 @@ def convert_to_mp3_and_transcribe(video_url, language, use_cache=True):
                 break
         
         if not mp3_file:
-            print("[DEBUG] هیچ MP3 پیدا نشد.")
-            status_msg = "خطا در دانلود یا تبدیل. مطمئن شوید لینک معتبر است."
-            save_result_to_cache(video_url, language, None, None, status_msg)
-            return None, None, status_msg, cache_key
+            return None, None, "خطا در دانلود یا تبدیل."
         
         progress(0.3, desc="دانلود کامل. کپی MP3...")
         
@@ -134,46 +158,28 @@ def convert_to_mp3_and_transcribe(video_url, language, use_cache=True):
         if os.path.exists(mp3_file):
             os.remove(mp3_file)
         
-        print(f"[DEBUG] MP3 آماده: {temp_mp3.name}, اندازه: {os.path.getsize(temp_mp3.name)/1024:.1f} KB")
-        
-        progress(0.5, desc="MP3 آماده. شروع استخراج متن با Google...")
+        progress(0.5, desc="MP3 آماده. شروع استخراج متن...")
         
         # استخراج متن
         text, error_msg = transcribe_audio(temp_mp3.name, progress, language)
         
         if text is None:
-            status_msg = f"MP3 آماده است، اما استخراج متن fail شد. {error_msg}"
-            save_result_to_cache(video_url, language, temp_mp3.name, None, status_msg)
-            return temp_mp3.name, None, status_msg, cache_key
-        
-        progress(1.0, desc="استخراج متن کامل شد!")
+            return temp_mp3.name, None, f"MP3 آماده، اما استخراج متن fail شد. {error_msg}"
         
-        print(f"[DEBUG] متن نهایی (اولین 100 کاراکتر): {text[:100]}...")
+        progress(1.0, desc="کامل شد!")
         
-        status_msg = f"موفق! زبان: {language_display(language)}. {len(text.split())} کلمه استخراج شد."
-        save_result_to_cache(video_url, language, temp_mp3.name, text, status_msg)
-        
-        return temp_mp3.name, text, status_msg, cache_key
+        return temp_mp3.name, text, f"موفق! {len(text.split())} کلمه استخراج شد."
     
     except Exception as e:
         print(f"[ERROR] خطای کلی: {str(e)}")
-        status_msg = f"خطا کلی: {str(e)}"
-        save_result_to_cache(video_url, language, None, None, status_msg)
-        return None, None, status_msg, cache_key
+        return None, None, f"خطا: {str(e)}"
 
 def language_display(lang_code):
     """نمایش نام زبان"""
-    if lang_code == 'fa-IR':
-        return "پارسی"
-    elif lang_code == 'en-US':
-        return "انگلیسی"
-    else:
-        return lang_code
+    return "پارسی" if lang_code == 'fa-IR' else "انگلیسی" if lang_code == 'en-US' else lang_code
 
 def transcribe_audio(mp3_path, progress, language, chunk_length_ms=60000, overlap_ms=5000):
-    """
-    استخراج متن با Google STT + retry برای rate limit. chunk 60s.
-    """
+    """استخراج متن - کد قبلی شما"""
     recognizer = sr.Recognizer()
     recognizer.energy_threshold = 300
     recognizer.dynamic_energy_threshold = True
@@ -185,18 +191,16 @@ def transcribe_audio(mp3_path, progress, language, chunk_length_ms=60000, overla
     temp_wav_dir = tempfile.mkdtemp()
     audio = AudioSegment.from_mp3(mp3_path)
     duration_ms = len(audio)
+    
     if duration_ms == 0:
-        print("[DEBUG] فایل صوتی خالی!")
-        return None, "فایل صوتی خالی یا بدون صدا."
+        return None, "فایل صوتی خالی"
     
     step_size = chunk_length_ms - overlap_ms
     if step_size <= 0:
         step_size = chunk_length_ms // 2
     num_chunks = max(1, (duration_ms // step_size) + 1)
     
-    print(f"[DEBUG] مدت: {duration_ms/1000:.1f}s, chunkها: {num_chunks}, گام: {step_size/1000:.1f}s")
-    
-    progress(0.5, desc=f"تقسیم به {num_chunks} chunk 60s (زبان: {language_display(language)})...")
+    print(f"[DEBUG] مدت: {duration_ms/1000:.1f}s, chunks: {num_chunks}")
     
     i = 0
     chunk_idx = 1
@@ -205,14 +209,12 @@ def transcribe_audio(mp3_path, progress, language, chunk_length_ms=60000, overla
         chunk = audio[i:end_pos]
         
         if len(chunk) < 3000:
-            print(f"[DEBUG] Chunk {chunk_idx} خیلی کوتاه ({len(chunk)/1000}s), رد شد.")
             break
         
         temp_wav = os.path.join(temp_wav_dir, f"chunk_{i}.wav")
         
         try:
             chunk.export(temp_wav, format="wav")
-            print(f"[DEBUG] Chunk {chunk_idx} export شد: {temp_wav}")
             
             text_chunk = None
             retry_count = 0
@@ -220,36 +222,27 @@ def transcribe_audio(mp3_path, progress, language, chunk_length_ms=60000, overla
             
             while retry_count < max_retries:
                 try:
-                    progress(0.5 + (i / duration_ms) * 0.5, desc=f"Chunk {chunk_idx}/{num_chunks} ({(i/1000):.0f}-{end_pos/1000:.0f}s, retry {retry_count+1})...")
+                    progress(0.5 + (i / duration_ms) * 0.5, desc=f"Chunk {chunk_idx}/{num_chunks}")
                     
                     with sr.AudioFile(temp_wav) as source:
                         recognizer.adjust_for_ambient_noise(source, duration=0.5)
-                        audio_data = recognizer.record(source, duration=None)
+                        audio_data = recognizer.record(source)
                     
                     text = recognizer.recognize_google(audio_data, language=language)
-                    if text.strip():
-                        text_chunk = text
-                        print(f"[DEBUG] Chunk {chunk_idx} موفق: {text[:50]}...")
-                        break
-                    else:
-                        text_chunk = "[سکوت]"
-                        print(f"[DEBUG] Chunk {chunk_idx} سکوت.")
-                        break
+                    text_chunk = text if text.strip() else "[سکوت]"
+                    break
                 
                 except sr.UnknownValueError:
                     text_chunk = "[نامشخص]"
-                    print(f"[DEBUG] Chunk {chunk_idx} نامشخص (نویز/سکوت).")
                     break
                 
                 except sr.RequestError as e:
                     retry_count += 1
-                    print(f"[DEBUG] Chunk {chunk_idx} RequestError (rate limit?): {str(e)}. Retry {retry_count}/{max_retries}")
                     if retry_count < max_retries:
                         time.sleep(2)
                     else:
-                        text_chunk = f"[خطا rate limit: {str(e)[:30]}...]"
+                        text_chunk = f"[خطا: {str(e)[:20]}]"
                         bad_chunks += 1
-                        print(f"[DEBUG] Chunk {chunk_idx} fail پس از retryها.")
                         break
             
             if text_chunk:
@@ -259,10 +252,8 @@ def transcribe_audio(mp3_path, progress, language, chunk_length_ms=60000, overla
             
             total_chunks += 1
         
-        except Exception as chunk_e:
-            print(f"[ERROR] Chunk {chunk_idx} (خطای کلی): {str(chunk_e)}")
-            text_chunk = f"[خطا chunk: {str(chunk_e)[:30]}...]"
-            full_text.append(text_chunk)
+        except Exception as e:
+            print(f"[ERROR] Chunk {chunk_idx}: {str(e)}")
             bad_chunks += 1
             total_chunks += 1
         
@@ -275,78 +266,69 @@ def transcribe_audio(mp3_path, progress, language, chunk_length_ms=60000, overla
     shutil.rmtree(temp_wav_dir, ignore_errors=True)
     
     final_text = ' '.join(full_text).strip()
-    error_msg = ""
     
     if not final_text:
-        error_msg = "هیچ chunk موفقی نبود."
-        return None, error_msg
+        return None, "هیچ متنی استخراج نشد"
     
     bad_ratio = bad_chunks / total_chunks if total_chunks > 0 else 1
     if bad_ratio > 0.7:
-        error_msg = f"بیش از 70% chunkها fail ({bad_ratio*100:.0f}%). ممکن است نویز باشد، rate limit گوگل، یا زبان اشتباه انتخاب شده."
-        return None, error_msg
-    
-    print(f"[DEBUG] {total_chunks} chunk پردازش شد, {bad_chunks} بد.")
+        return None, f"بیش از {bad_ratio*100:.0f}% خطا"
     
-    return final_text, error_msg
+    return final_text, ""
 
-# API endpoint برای دریافت نتیجه با cache key
-def get_cached_result(cache_key):
-    """API برای دریافت نتیجه ذخیره شده"""
-    mp3, text, status = get_result_from_cache(cache_key)
-    return {
-        "cache_key": cache_key,
-        "mp3_available": mp3 is not None,
-        "text": text,
-        "status": status
-    }
+# API endpoint
+@app.get("/api/check_result/{cache_key}")
+async def check_result_api(cache_key: str):
+    """API endpoint برای بررسی وضعیت نتیجه"""
+    result = get_result_from_cache(cache_key)
+    
+    if not result:
+        return JSONResponse({"status": 0, "message": "Not found"})
+    
+    if result['processing']:
+        return JSONResponse({"status": 0, "message": "Processing"})
+    
+    if result['completed']:
+        return JSONResponse({
+            "status": 1,
+            "text": result['text'],
+            "mp3_available": result['mp3_path'] is not None,
+            "status_message": result['status_msg']
+        })
+    
+    return JSONResponse({"status": 0, "message": "Unknown status"})
 
-# رابط Gradio با خروجی cache key
+# رابط Gradio
 iface = gr.Interface(
-    fn=convert_to_mp3_and_transcribe,
+    fn=convert_to_mp3_and_transcribe_wrapper,
     inputs=[
         gr.Textbox(
-            label="لینک ویدیو (یوتیوب یا MP4 مستقیم)",
-            placeholder="https://www.youtube.com/watch?v=... یا https://example.com/video.mp4"
+            label="لینک ویدیو",
+            placeholder="https://www.youtube.com/watch?v=..."
         ),
         gr.Dropdown(
-            choices=[
-                ("پارسی", "fa-IR"),
-                ("انگلیسی", "en-US"),
-            ],
+            choices=[("پارسی", "fa-IR"), ("انگلیسی", "en-US")],
             value="fa-IR",
-            label="زبان متن"
-        ),
-        gr.Checkbox(
-            label="استفاده از حافظه cache",
-            value=True,
-            visible=False  # مخفی کنیم چون همیشه فعال است
+            label="زبان"
         )
     ],
     outputs=[
         gr.File(label="دانلود MP3"),
-        gr.Textbox(label="متن استخراج‌شده (Google STT)", lines=10),
-        gr.Textbox(label="پیام وضعیت"),
-        gr.Textbox(label="Cache Key (برای دریافت مجدد نتیجه)", visible=True)
+        gr.Textbox(label="متن استخراج‌شده", lines=10),
+        gr.Textbox(label="وضعیت"),
+        gr.Textbox(label="Cache Key", visible=True)
     ],
-    title="تبدیل ویدیو به MP3 و استخراج متن (Google STT) - با Cache",
-    description="لینک ویدیو را وارد کنید و زبان را انتخاب کنید. نتایج برای 24 ساعت ذخیره می‌شوند.",
+    title="تبدیل ویدیو به MP3 و متن",
     examples=[
         ["https://www.youtube.com/watch?v=5qap5aO4i9A", "fa-IR"],
         ["https://www.youtube.com/watch?v=dQw4w9WgXcQ", "en-US"]
-    ],
-    allow_flagging="never",
-    cache_examples=False
+    ]
 )
 
-# اضافه کردن API route برای دسترسی به cache
-with gr.Blocks() as demo:
-    iface.render()
-    
-    # API endpoint مخفی
-    @gr.route("/api/get_result/{cache_key}")
-    def api_get_result(cache_key):
-        return get_cached_result(cache_key)
+# Mount FastAPI to Gradio
+from gradio import mount_gradio_app
+mount_gradio_app(app, iface, path="/")
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)