Update app.py

app.py

@@ -20,7 +20,7 @@ import google.generativeai as genai
 from pydantic import BaseModel
 from PIL import Image, ImageDraw, ImageFont
 from pydub import AudioSegment
-from gradio_client import Client, handle_file
+from groq import Groq  # اضافه شدن کتابخانه Groq
 
 app = FastAPI()
 
@@ -61,10 +61,9 @@ FONT_FILES_MAP = {
     "hasti": "Hasti.ttf",
 }
 
-# --- تنظیمات اتصال به اسپیس گِرادیو ویسپر و سرور جدید ---
-GRADIO_SPACE_URL = os.getenv("GRADIO_SPACE_URL", "Opera8/sadabematn")
-HF_TOKEN = os.getenv("HF_TOKEN", None)
-NEW_SPACE_URL = os.getenv("NEW_SPACE_URL", "https://opera8-tts3.hf.space")
+# دریافت توکن Groq و Gemini از تنظیمات سکرت اسپیس
+GROQ_API_KEY = os.getenv("GROQ_API_KEY", "")
+API_KEYS = [os.getenv("GEMINI_API_KEY")] if os.getenv("GEMINI_API_KEY") else []
 
 # --- سیستم صف و پایش موقت آپلود غیرهمگام ---
 class UploadJobStatus:
@@ -111,7 +110,7 @@ def load_all_styles():
 
 load_all_styles()
 
-# تنظیم همزمانی بسیار بالا (ارسال همزمان تمامی قطعات برش‌خورده در یک مرحله)
+# تنظیم همزمانی پردازش
 CONCURRENCY_LIMIT = 20
 GEMINI_SEMAPHORE = asyncio.Semaphore(CONCURRENCY_LIMIT)
 
@@ -185,7 +184,6 @@ async def queue_worker():
                 job.error_message = str(e)
         render_queue.task_done()
 
-# کارگر پس‌زمینه برای پاکسازی خودکار فایل‌های خروجی قدیمی‌تر از ۲ ساعت
 async def cleanup_old_files_loop():
     print("--- File Cleanup Worker Started ---")
     while True:
@@ -194,11 +192,9 @@ async def cleanup_old_files_loop():
             now = time.time()
             for filename in os.listdir(TEMP_DIR):
                 file_path = os.path.join(TEMP_DIR, filename)
-                # شناسایی فایل‌های خروجی نهایی
                 if filename.endswith(".mp4") and "_final_" in filename:
                     try:
                         mtime = os.path.getmtime(file_path)
-                        # ۷۲۰۰ ثانیه معادل ۲ ساعت است
                         if now - mtime > 7200:
                             os.remove(file_path)
                             print(f"Cleanup: Removed expired final video: {filename}")
@@ -451,8 +447,6 @@ def generate_subtitle_video(data: ProcessRequest, temp_dir: str):
                 seg.words.sort(key=lambda x: x.start)
                 words = [w.word for w in seg.words]
 
-                # استفاده از منطق فریم‌بندی زمانی دقیق برای تمامی استایل‌ها
-                # این کار مانع از کشیده شدن یا جابجایی زمان کلمات دیگر در صورت حذف یک کلمه می‌شود
                 SUB_FRAME_DURATION = 0.025 if data.style.name == "falling_words" else 0.05
                 time_cursor = start_time
                 ANIMATION_DURATION = 0.4 
@@ -530,82 +524,31 @@ def generate_style_api(req: StylePrompt):
         except: continue
     return {"primaryColor":"#FFFFFF", "outlineColor":"#000000", "font":"vazir", "fontSize":60, "backType":"solid"}
 
-def smart_split_audio(file_path):
-    """
-    برش هوشمند فایل صوتی بر اساس درخواست:
-    - اگر زیر ۳۰ ثانیه باشد برشی نمی‌خورد.
-    - در غیر اینصورت بین ۱۵ تا ۳۰ ثانیه دنبال سکوت می‌گردد.
-    - اگر در این بازه سکوت مناسبی نبود، بین ۱۰ تا ۴۰ ثانیه دنبال سکوت می‌گردد.
-    """
-    audio = AudioSegment.from_file(file_path)
-    length_ms = len(audio)
-    chunks_info = []
+# --- تابع جدید برای ارسال فایل صوتی به Groq و تحلیل دقیق کلمه‌به‌کلمه ---
+async def transcribe_audio_via_groq(audio_path: str):
+    if not GROQ_API_KEY:
+        raise Exception("متغیر محیطی GROQ_API_KEY در قسمت Secrets تنظیم نشده است.")
     
-    start_ms = 0
-    # محاسبه حجم صدای میانگین کل فایل به عنوان معیار سکوت (۴۰ درصد صدای کل)
-    avg_rms = audio.rms
-    silence_threshold = avg_rms * 0.4 if avg_rms > 0 else 500
+    # راه‌اندازی کلاینت Groq
+    client = Groq(api_key=GROQ_API_KEY)
     
-    while start_ms < length_ms:
-        # اگر زمان باقیمانده کمتر از ۳۰ ثانیه بود، همه را در یک قطعه پردازش کن
-        if length_ms - start_ms <= 30 * 1000:
-            end_ms = length_ms
-        else:
-            # 1. جستجوی سکوت در بازه 15 تا 30 ثانیه
-            search_start = start_ms + (15 * 1000)
-            search_end = min(start_ms + (30 * 1000), length_ms)
-            window = audio[search_start:search_end]
-            
-            min_loudness = float('inf')
-            best_cut_rel = search_end - search_start
-            step = 100
+    # فراخوانی متد همگام به صورت غ��رهمگام با استفاده از نخ مستقل
+    def call_groq():
+        with open(audio_path, "rb") as file:
+            return client.audio.transcriptions.create(
+                file=(os.path.basename(audio_path), file.read()),
+                model="whisper-large-v3",
+                response_format="verbose_json",
+                timestamp_granularities=["word"],
+                temperature=0.0,
+                language="fa",  # تضمین پردازش به عنوان زبان فارسی
+                prompt="دقیق‌ترین زیرنویس چسبیده فارسی با رعایت علائم نگارشی، فاصله‌گذاری، نیم‌فاصله‌ها و بدون جا انداختن کلمات."
+            )
             
-            if len(window) > 0:
-                for i in range(0, len(window), step):
-                    chunk_check = window[i:i+step]
-                    if chunk_check.rms < min_loudness:
-                        min_loudness = chunk_check.rms
-                        best_cut_rel = i
-            
-            # 2. بررسی اینکه آیا سکوت پیدا شده خوب است؟ 
-            # و اینکه آیا اصلاً اجازه گسترش بازه تا 40 ثانیه را داریم؟ (باقیمانده > 40s)
-            if min_loudness > silence_threshold and (length_ms - start_ms) > 30 * 1000:
-                # جستجوی ثانویه در بازه 10 تا 40 ثانیه (چون سکوت خوبی پیدا نشد)
-                search_start_fb = start_ms + (10 * 1000)
-                search_end_fb = min(start_ms + (40 * 1000), length_ms)
-                window_fb = audio[search_start_fb:search_end_fb]
-                
-                min_loudness_fb = float('inf')
-                best_cut_rel_fb = search_end_fb - search_start_fb
-                
-                if len(window_fb) > 0:
-                    for i in range(0, len(window_fb), step):
-                        chunk_check = window_fb[i:i+step]
-                        if chunk_check.rms < min_loudness_fb:
-                            min_loudness_fb = chunk_check.rms
-                            best_cut_rel_fb = i
-                
-                # اعمال نتیجه جستجوی ثانویه (گسترده‌تر)
-                end_ms = search_start_fb + best_cut_rel_fb
-            else:
-                # اعمال نتیجه جستجوی اولیه (همان 15 تا 30 ثانیه)
-                end_ms = search_start + best_cut_rel
+    transcription = await asyncio.to_thread(call_groq)
+    return transcription
 
-        chunk = audio[start_ms:end_ms]
-        chunk_filename = f"{file_path}_{start_ms}.wav"
-        chunk.export(chunk_filename, format="wav", parameters=["-ar", "16000"])
-        
-        chunks_info.append({
-            "path": chunk_filename,
-            "offset": start_ms / 1000.0,
-            "duration": (end_ms - start_ms) / 1000.0,
-            "index": len(chunks_info) 
-        })
-        start_ms = end_ms
-        
-    return chunks_info
-
-# --- پردازش موقت در صف پس‌زمینه برای داک داکر غیرهمگام ---
+# --- پردازش موقت در صف پس‌زمینه ---
 async def bg_process_upload(task_id: str, raw_path: str, fixed_path: str, audio_path: str):
     job = upload_jobs.get(task_id)
     if not job:
@@ -613,6 +556,7 @@ async def bg_process_upload(task_id: str, raw_path: str, fixed_path: str, audio_
     
     job.status = UploadJobStatus.PROCESSING
     try:
+        # ۱. تبدیل ویدیوی خام به فرمت استاندارد 30fps h264
         proc1 = await asyncio.create_subprocess_exec(
             "ffmpeg", "-y", "-i", raw_path, "-r", "30", "-c:v", "libx264", 
             "-preset", "ultrafast", "-c:a", "copy", fixed_path,
@@ -622,32 +566,72 @@ async def bg_process_upload(task_id: str, raw_path: str, fixed_path: str, audio_
         
         w, h, total_duration = get_video_info(fixed_path)
         
+        # ۲. استخراج مستقیم صدا به صورت MP3 با نرخ بیت پایین‌تر (کیفیت عالی برای Whisper و حجم بسیار کم زیر ۲۵ مگابایت)
         proc2 = await asyncio.create_subprocess_exec(
-            "ffmpeg", "-y", "-i", fixed_path, "-vn", "-acodec", "pcm_s16le", 
-            "-ar", "16000", "-ac", "1", audio_path,
+            "ffmpeg", "-y", "-i", fixed_path, "-vn", "-acodec", "libmp3lame", 
+            "-ar", "16000", "-ac", "1", "-b:a", "64k", audio_path,
             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
         )
         await proc2.communicate()
         
-        # استفاده از سیستم جدید هوشمند برش بین 15 تا 30 ثانیه در نقاط سکوت (گسترش تا 40 ثانیه در صورت لزوم)
-        audio_chunks = smart_split_audio(audio_path)
-        print(f"--- [BG Task {task_id}] Processing {len(audio_chunks)} chunks concurrently ---")
+        print(f"--- [BG Task {task_id}] Transcribing audio with Groq Whisper-large-v3 in one step ---")
         
-        # تمامی قطعات برش خورده به صورت یکجا و موازی ارسال می‌شوند
-        tasks = [process_single_chunk_async(chunk) for chunk in audio_chunks]
-        results = await asyncio.gather(*tasks)
+        # ۳. ارسال مستقیم فایل صوتی فشرده شده به Groq
+        transcription = await transcribe_audio_via_groq(audio_path)
         
-        final_segs = []
-        final_style = None
-        errors = []
-
-        for segs, style, err in results:
-            if style and not final_style:
-                final_style = style
-            final_segs.extend(segs)
-            if err:
-                errors.append(err)
-
+        # ۴. تحلیل خروجی Pydantic یا دیکشنری دریافتی
+        if hasattr(transcription, "model_dump"):
+            data = transcription.model_dump()
+        elif hasattr(transcription, "dict"):
+            data = transcription.dict()
+        elif isinstance(transcription, dict):
+            data = transcription
+        else:
+            try:
+                data = dict(transcription)
+            except:
+                data = {}
+                if hasattr(transcription, "words"):
+                    data["words"] = getattr(transcription, "words", [])
+                if hasattr(transcription, "segments"):
+                    data["segments"] = getattr(transcription, "segments", [])
+        
+        raw_word_items = data.get("words", [])
+        # در صورت نبود آرایه مستقیم کلمات، آن را از میان سگمنت‌ها استخراج می‌کنیم
+        if not raw_word_items and "segments" in data:
+            segments = data.get("segments", [])
+            for seg in segments:
+                if isinstance(seg, dict) and "words" in seg:
+                    raw_word_items.extend(seg["words"])
+                elif hasattr(seg, "words"):
+                    raw_word_items.extend(getattr(seg, "words", []))
+                    
+        # حالت بک‌آپ (اگر کلمه‌به‌کلمه خالی بود، از سطح سگمنت کلمات را استخراج می‌کنیم)
+        if not raw_word_items:
+            segments = data.get("segments", [])
+            if segments:
+                print(f"[{task_id}] No word timestamps found. Falling back to segment level timestamps.")
+                for seg in segments:
+                    seg_text = getattr(seg, "text", "") if not isinstance(seg, dict) else seg.get("text", "")
+                    seg_start = float(getattr(seg, "start", 0)) if not isinstance(seg, dict) else float(seg.get("start", 0))
+                    seg_end = float(getattr(seg, "end", 0)) if not isinstance(seg, dict) else float(seg.get("end", 0))
+                    words_list = seg_text.split()
+                    duration = seg_end - seg_start
+                    word_duration = duration / max(1, len(words_list))
+                    
+                    sc_words = []
+                    for i, w in enumerate(words_list):
+                        w_start = seg_start + (i * word_duration)
+                        w_end = w_start + word_duration
+                        sc_words.append({
+                            "word": w,
+                            "start": round(w_start, 3),
+                            "end": round(w_end, 3),
+                            "highlight": False
+                        })
+                    raw_word_items.extend(sc_words)
+
+        # پاکسازی سریع فایلهای موقت صوتی و ویدئوی خام
         if os.path.exists(audio_path):
             try: os.remove(audio_path)
             except: pass
@@ -655,19 +639,52 @@ async def bg_process_upload(task_id: str, raw_path: str, fixed_path: str, audio_
             try: os.remove(raw_path)
             except: pass
 
-        if not final_segs:
-            err_summary = " | ".join(list(set(errors))) if errors else "هیچ متنی از تحلیل صدا استخراج نشد."
+        if not raw_word_items:
             job.status = UploadJobStatus.FAILED
-            job.error_message = f"تبدیل گفتار به متن ناموفق بود. خطاهای شناسایی شده: {err_summary}"
+            job.error_message = "تبدیل گفتار به متن ناموفق بود. هیچ متنی شناسایی نشد."
             return
 
+        # ۵. گروه‌بندی کلمات دریافت شده به صورت دسته‌های ۵ تایی (بسیار خوانا و استاندارد برای ریلز)
+        final_segs = []
+        chunk_size = 5
+        for k in range(0, len(raw_word_items), chunk_size):
+            sub = raw_word_items[k:k+chunk_size]
+            if not sub: continue
+            sc_words = []
+            for w in sub:
+                if not isinstance(w, dict):
+                    word_text = getattr(w, "word", getattr(w, "text", ""))
+                    word_start = float(getattr(w, "start", getattr(w, "start_time", 0)))
+                    word_end = float(getattr(w, "end", getattr(w, "end_time", 0)))
+                else:
+                    word_text = w.get("word", w.get("text", ""))
+                    word_start = float(w.get("start", w.get("start_time", 0)))
+                    word_end = float(w.get("end", w.get("end_time", 0)))
+                
+                sc_words.append({
+                    "word": word_text,
+                    "start": round(word_start, 3),
+                    "end": round(word_end, 3),
+                    "highlight": False
+                })
+            
+            if sc_words:
+                final_segs.append({
+                    "start": sc_words[0]["start"],
+                    "end": sc_words[-1]["end"],
+                    "text": " ".join([x["word"] for x in sc_words]),
+                    "words": sc_words
+                })
+
+        suggested_style = {"primaryColor": "#FFFFFF", "outlineColor": "#000000", "font": "vazir", "fontSize": 60, "backType": "solid"}
+
         job.result = {
             "file_id": task_id,
             "url": f"/temp/{task_id}.mp4",
             "width": w,
             "height": h,
             "segments": final_segs,
-            "suggested_style": final_style or {"primaryColor": "#FFFFFF", "outlineColor": "#000000", "font": "vazir", "fontSize": 60, "backType": "solid"}
+            "suggested_style": suggested_style
         }
         job.status = UploadJobStatus.COMPLETED
 
@@ -681,171 +698,13 @@ async def bg_process_upload(task_id: str, raw_path: str, fixed_path: str, audio_
         job.status = UploadJobStatus.FAILED
         job.error_message = f"Processing Error: {str(e)}"
 
-# --- پردازشگر ارتباط با API وب‌سرویس جدید در هاگینگ‌فیس شما ---
-async def process_single_chunk_async(chunk_data):
-    c_path = chunk_data["path"]
-    c_offset = chunk_data["offset"]
-    c_duration = chunk_data["duration"]
-    chunk_idx = chunk_data["index"]
-    
-    print(f"[{chunk_idx}] Start processing chunk... Offset: {c_offset}s, Duration: {c_duration}s")
-    result_segs = []
-    style_suggestion = None
-    error_msg = None
-    
-    async with GEMINI_SEMAPHORE:
-        for attempt in range(5):
-            try:
-                chunk_run_id = f"stt_chunk_{uuid.uuid4().hex[:12]}"
-                
-                upload_url = f"{NEW_SPACE_URL}/api/webhook/upload"
-                print(f"[{chunk_idx}] Uploading chunk file to {upload_url} (Attempt {attempt + 1}/5)...")
-                
-                with open(c_path, "rb") as f:
-                    files = {"file": f}
-                    data = {"run_id": chunk_run_id, "ext": "wav"}
-                    upload_res = await asyncio.to_thread(
-                        lambda: requests.post(upload_url, data=data, files=files, timeout=30)
-                    )
-                
-                if not upload_res.ok:
-                    error_msg = f"خطا در بارگذاری چنک صوتی روی سرور: {upload_res.status_code}"
-                    print(f"[{chunk_idx}] Warning: {error_msg}")
-                    await asyncio.sleep(2)
-                    continue
-
-                generate_url = f"{NEW_SPACE_URL}/api/generate"
-                file_url = f"{NEW_SPACE_URL}/static/images/{chunk_run_id}.wav"
-                
-                config_prompt = f"config_url: {file_url} config_lang: Persian / فارسی config_optimize: true config_token: none"
-                
-                print(f"[{chunk_idx}] Dispatching transcription action to {generate_url}...")
-                payload = {
-                    "prompt": config_prompt,
-                    "width": 1024,
-                    "height": 1024,
-                    "action_name": "matnbesada"
-                }
-                
-                gen_res = await asyncio.to_thread(
-                    lambda: requests.post(generate_url, json=payload, timeout=30)
-                )
-                
-                if not gen_res.ok:
-                    error_msg = f"خطا در ارسال درخواست رندر به سرور: {gen_res.status_code}"
-                    print(f"[{chunk_idx}] Warning: {error_msg}")
-                    await asyncio.sleep(2)
-                    continue
-                    
-                gen_data = gen_res.json()
-                if gen_data.get("status") != "success" or not gen_data.get("run_id"):
-                    error_msg = "پاسخ نامعتبر در ثبت تسک پردازش."
-                    print(f"[{chunk_idx}] Warning: {error_msg}")
-                    await asyncio.sleep(2)
-                    continue
-                    
-                action_run_id = gen_data["run_id"]
-                print(f"[{chunk_idx}] Action dispatched successfully. Action ID: {action_run_id}")
-                
-                json_url = f"{NEW_SPACE_URL}/static/images/{action_run_id}.json"
-                
-                print(f"[{chunk_idx}] Starting status polling for json file...")
-                is_ready = False
-                poll_attempts = 0
-                max_poll_attempts = 100 
-                
-                while poll_attempts < max_poll_attempts:
-                    poll_attempts += 1
-                    check_res = await asyncio.to_thread(
-                        lambda: requests.head(json_url, timeout=10)
-                    )
-                    if check_res.ok:
-                        is_ready = True
-                        break
-                    await asyncio.sleep(3)
-                
-                if not is_ready:
-                    error_msg = "زمان انتظار برای دریافت خروجی به پایان رسید."
-                    print(f"[{chunk_idx}] Warning: {error_msg}")
-                    continue
-                    
-                print(f"[{chunk_idx}] Files are ready! Fetching results...")
-                fetch_json_res = await asyncio.to_thread(lambda: requests.get(json_url, timeout=15))
-                
-                raw_word_items = []
-                if fetch_json_res.ok:
-                    try:
-                        words_data = json.loads(fetch_json_res.text)
-                        if isinstance(words_data, dict):
-                            if "words" in words_data:
-                                words_data = words_data["words"]
-                            elif "segments" in words_data:
-                                words_data = words_data["segments"]
-                            else:
-                                for val in words_data.values():
-                                    if isinstance(val, list):
-                                        words_data = val
-                                        break
-                        if isinstance(words_data, list):
-                            raw_word_items = words_data
-                    except Exception as je:
-                        print(f"[{chunk_idx}] JSON decode failed: {je}")
-
-                if raw_word_items:
-                    print(f"[{chunk_idx}] Transcribed successfully. Processing {len(raw_word_items)} raw words...")
-                    
-                    chunk_size = 7
-                    for k in range(0, len(raw_word_items), chunk_size):
-                        sub = raw_word_items[k:k+chunk_size]
-                        if not sub: continue
-                        sc_words = []
-                        for w in sub:
-                            if not isinstance(w, dict): continue
-                            
-                            word_text = w.get("word", w.get("text", ""))
-                            word_start = float(w.get("start", w.get("start_time", 0)))
-                            word_end = float(w.get("end", w.get("end_time", 0)))
-                            
-                            sc_words.append({
-                                "word": word_text,
-                                "start": round(c_offset + word_start, 3),
-                                "end": round(c_offset + word_end, 3),
-                                "highlight": False
-                            })
-                        
-                        if sc_words:
-                            result_segs.append({
-                                "start": sc_words[0]["start"], 
-                                "end": sc_words[-1]["end"], 
-                                "text": " ".join([x["word"] for x in sc_words]), 
-                                "words": sc_words
-                            })
-                    
-                    print(f"[{chunk_idx}] Successfully generated {len(result_segs)} subtitle segments.")
-                    error_msg = None
-                    break 
-                else:
-                    error_msg = "هیچ زمان‌بندی خامی از سرور دریافت نشد."
-                    print(f"[{chunk_idx}] Warning: {error_msg}")
-                    
-            except Exception as e:
-                error_msg = f"{type(e).__name__}: {str(e)}"
-                print(f"[{chunk_idx}] ERROR calling custom Space STT: {error_msg}")
-                await asyncio.sleep(2 + attempt * 2)
-
-    if os.path.exists(c_path):
-        try: os.remove(c_path)
-        except: pass
-        
-    return result_segs, style_suggestion, error_msg
-
 @app.post("/api/upload")
 async def upload(background_tasks: BackgroundTasks, file: UploadFile = File(...)):
     task_id = str(uuid.uuid4())[:8]
     ext = file.filename.split('.')[-1]
     raw_path = f"{TEMP_DIR}/{task_id}_raw.{ext}"
     fixed_path = f"{TEMP_DIR}/{task_id}.mp4"
-    audio_path = f"{TEMP_DIR}/{task_id}.wav"
+    audio_path = f"{TEMP_DIR}/{task_id}.mp3"  # ذخیره به عنوان MP3
     
     try:
         with open(raw_path, "wb") as f:
@@ -884,13 +743,11 @@ async def delete_project_files(file_id: str):
     if "/" in file_id or "\\" in file_id or ".." in file_id:
         raise HTTPException(400, "Invalid file_id")
     
-    # ۱. حذف ویدیوی اصلی آپلود شده
     raw_video_path = os.path.join(TEMP_DIR, f"{file_id}.mp4")
     if os.path.exists(raw_video_path):
         try: os.remove(raw_video_path)
         except Exception as e: print(f"Error removing raw video: {e}")
     
-    # ۲. حذف تمامی خروجی‌های رندر شده مرتبط با این پروژه
     final_patterns = os.path.join(TEMP_DIR, f"{file_id}_final_*.mp4")
     for f_path in glob.glob(final_patterns):
         try: os.remove(f_path)