Update app.py

app.py

@@ -1,4 +1,4 @@
-from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi import FastAPI, File, UploadFile, HTTPException, BackgroundTasks
 from fastapi.responses import JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
 import whisper
@@ -11,6 +11,8 @@ import hashlib
 import json
 import sqlite3
 from datetime import datetime
+import threading
+import time
 
 # تنظیم لاگ
 logging.basicConfig(level=logging.INFO)
@@ -31,7 +33,7 @@ logger.info(f"Loading model on {device}")
 model = whisper.load_model("large-v3", device=device)
 logger.info("Model loaded successfully")
 
-# ایجاد دیتابیس کش
+# ایجاد دیتابیس کش و وضعیت
 def init_cache_db():
     conn = sqlite3.connect('transcription_cache.db')
     cursor = conn.cursor()
@@ -45,6 +47,22 @@ def init_cache_db():
             created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
         )
     ''')
+    
+    # جدول جدید برای ردیابی وضعیت پردازش
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS processing_status (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            file_hash TEXT UNIQUE,
+            filename TEXT,
+            file_size INTEGER,
+            status TEXT DEFAULT 'processing',
+            progress INTEGER DEFAULT 0,
+            estimated_time INTEGER DEFAULT 0,
+            started_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    ''')
+    
     conn.commit()
     conn.close()
 
@@ -80,12 +98,140 @@ def save_to_cache(file_hash, filename, file_size, transcription):
     except Exception as e:
         logger.error(f"Error saving to cache: {e}")
 
-# پاک کردن کش قدیمی (بیش از 30 روز)
+# بررسی وضعیت پردازش
+def get_processing_status(file_hash):
+    try:
+        conn = sqlite3.connect('transcription_cache.db')
+        cursor = conn.cursor()
+        cursor.execute('''
+            SELECT status, progress, estimated_time, 
+                   (julianday('now') - julianday(started_at)) * 24 * 60 as elapsed_minutes
+            FROM processing_status WHERE file_hash = ?
+        ''', (file_hash,))
+        result = cursor.fetchone()
+        conn.close()
+        if result:
+            return {
+                'status': result[0],
+                'progress': result[1], 
+                'estimated_time': result[2],
+                'elapsed_minutes': int(result[3])
+            }
+        return None
+    except:
+        return None
+
+# به‌روزرسانی وضعیت پردازش
+def update_processing_status(file_hash, status=None, progress=None, estimated_time=None):
+    try:
+        conn = sqlite3.connect('transcription_cache.db')
+        cursor = conn.cursor()
+        
+        updates = []
+        params = []
+        
+        if status:
+            updates.append("status = ?")
+            params.append(status)
+        if progress is not None:
+            updates.append("progress = ?")
+            params.append(progress)
+        if estimated_time is not None:
+            updates.append("estimated_time = ?")
+            params.append(estimated_time)
+            
+        updates.append("updated_at = CURRENT_TIMESTAMP")
+        params.append(file_hash)
+        
+        query = f"UPDATE processing_status SET {', '.join(updates)} WHERE file_hash = ?"
+        cursor.execute(query, params)
+        conn.commit()
+        conn.close()
+    except Exception as e:
+        logger.error(f"Error updating status: {e}")
+
+# افزودن وضعیت پردازش جدید
+def add_processing_status(file_hash, filename, file_size, estimated_time):
+    try:
+        conn = sqlite3.connect('transcription_cache.db')
+        cursor = conn.cursor()
+        cursor.execute('''
+            INSERT OR REPLACE INTO processing_status 
+            (file_hash, filename, file_size, status, progress, estimated_time)
+            VALUES (?, ?, ?, 'processing', 0, ?)
+        ''', (file_hash, filename, file_size, estimated_time))
+        conn.commit()
+        conn.close()
+    except Exception as e:
+        logger.error(f"Error adding processing status: {e}")
+
+# حذف وضعیت پردازش
+def remove_processing_status(file_hash):
+    try:
+        conn = sqlite3.connect('transcription_cache.db')
+        cursor = conn.cursor()
+        cursor.execute('DELETE FROM processing_status WHERE file_hash = ?', (file_hash,))
+        conn.commit()
+        conn.close()
+    except Exception as e:
+        logger.error(f"Error removing processing status: {e}")
+
+# تخمین زمان پردازش بر اساس سایز فایل (بر حسب دقیقه)
+def estimate_processing_time(file_size_mb):
+    # تخمین تقریبی: هر MB حدود 30 ثانیه روی CPU
+    estimated_seconds = file_size_mb * 30
+    return int(estimated_seconds / 60) + 1  # به دقیقه تبدیل + 1 دقیقه امان
+
+# پردازش پس‌زمینه
+def background_transcription(file_path, file_hash, filename, file_size):
+    try:
+        logger.info(f"Starting background transcription for {filename}")
+        
+        # شروع پردازش
+        update_processing_status(file_hash, status='processing', progress=10)
+        
+        result = model.transcribe(
+            file_path, 
+            fp16=False if device == "cpu" else True,
+            language=None,
+            task="transcribe",
+            verbose=False,
+            word_timestamps=False
+        )
+        
+        update_processing_status(file_hash, progress=80)
+        
+        text = result["text"].strip()
+        if not text:
+            text = "متن شناسایی نشد"
+        
+        # ذخیره در کش
+        save_to_cache(file_hash, filename, file_size, text)
+        
+        # تکمیل پردازش
+        update_processing_status(file_hash, status='completed', progress=100)
+        
+        logger.info(f"Background transcription completed for {filename}")
+        
+    except Exception as e:
+        logger.error(f"Error in background transcription: {e}")
+        update_processing_status(file_hash, status='error', progress=0)
+    
+    finally:
+        # حذف فایل موقت
+        if os.path.exists(file_path):
+            try:
+                os.unlink(file_path)
+            except:
+                pass
+
+# پاک کردن کش قدیمی
 def cleanup_old_cache():
     try:
         conn = sqlite3.connect('transcription_cache.db')
         cursor = conn.cursor()
         cursor.execute("DELETE FROM cache WHERE created_at < datetime('now', '-30 days')")
+        cursor.execute("DELETE FROM processing_status WHERE started_at < datetime('now', '-1 days')")
         conn.commit()
         conn.close()
     except Exception as e:
@@ -100,16 +246,19 @@ async def root():
     cursor = conn.cursor()
     cursor.execute('SELECT COUNT(*) FROM cache')
     cache_count = cursor.fetchone()[0]
+    cursor.execute('SELECT COUNT(*) FROM processing_status WHERE status = "processing"')
+    processing_count = cursor.fetchone()[0]
     conn.close()
     
     return {
         "message": "Whisper API is running", 
         "device": device,
-        "cached_files": cache_count
+        "cached_files": cache_count,
+        "currently_processing": processing_count
     }
 
 @app.post("/transcribe")
-async def transcribe_audio(file: UploadFile = File(...)):
+async def transcribe_audio(background_tasks: BackgroundTasks, file: UploadFile = File(...)):
     tmp_file_path = None
     
     try:
@@ -120,7 +269,9 @@ async def transcribe_audio(file: UploadFile = File(...)):
         
         contents = await file.read()
         file_size = len(contents)
-        logger.info(f"File read successfully, size: {file_size} bytes")
+        file_size_mb = file_size / (1024 * 1024)
+        
+        logger.info(f"File read successfully, size: {file_size} bytes ({file_size_mb:.1f} MB)")
         
         if file_size > 50 * 1024 * 1024:
             raise HTTPException(status_code=413, detail="File too large")
@@ -136,52 +287,80 @@ async def transcribe_audio(file: UploadFile = File(...)):
         cached_result = get_from_cache(file_hash)
         if cached_result:
             logger.info("Found in cache, returning cached result")
+            # حذف وضعیت پردازش اگر وجود دارد
+            remove_processing_status(file_hash)
             return JSONResponse({
                 "text": cached_result,
                 "from_cache": True,
                 "message": "نتیجه از کش بازگردانده شد"
             })
         
-        logger.info("Not found in cache, processing...")
+        # بررسی وضعیت پردازش فعلی
+        processing_status = get_processing_status(file_hash)
+        if processing_status:
+            logger.info("File is currently being processed")
+            return JSONResponse({
+                "status": "processing",
+                "progress": processing_status['progress'],
+                "estimated_time": processing_status['estimated_time'],
+                "elapsed_minutes": processing_status['elapsed_minutes'],
+                "message": f"فایل در حال پردازش است. لطفا {processing_status['estimated_time'] - processing_status['elapsed_minutes']} دقیقه صبر کنید"
+            })
+        
+        logger.info("Starting new processing...")
         
         # تشخیص فرمت فایل
         file_ext = os.path.splitext(file.filename)[1].lower()
         if not file_ext:
             file_ext = ".wav"
         
+        # ذخیره فایل موقت
         with tempfile.NamedTemporaryFile(delete=False, suffix=file_ext) as tmp_file:
             tmp_file.write(contents)
             tmp_file_path = tmp_file.name
         
         logger.info(f"Temp file created: {tmp_file_path}")
         
-        result = model.transcribe(
-            tmp_file_path, 
-            fp16=False if device == "cpu" else True,
-            language=None,
-            task="transcribe",
-            verbose=False,
-            word_timestamps=False
-        )
-        
-        logger.info("Transcription completed")
-        
-        text = result["text"].strip()
-        if not text:
-            text = "متن شناسایی نشد"
-        
-        # ذخیره در کش
-        save_to_cache(file_hash, file.filename, file_size, text)
-        logger.info("Result saved to cache")
+        # تخمین زمان پردازش
+        estimated_time = estimate_processing_time(file_size_mb)
         
-        # پاک کردن کش قدیمی
-        cleanup_old_cache()
+        # فایل کوچک (کمتر از 5MB) - پردازش فوری
+        if file_size_mb < 5:
+            result = model.transcribe(
+                tmp_file_path, 
+                fp16=False if device == "cpu" else True,
+                language=None,
+                task="transcribe",
+                verbose=False,
+                word_timestamps=False
+            )
+            
+            text = result["text"].strip()
+            if not text:
+                text = "متن شناسایی نشد"
+            
+            # ذخیره در کش
+            save_to_cache(file_hash, file.filename, file_size, text)
+            
+            return JSONResponse({
+                "text": text,
+                "from_cache": False,
+                "message": "پردازش جدید انجام شد و در کش ذخیره شد"
+            })
         
-        return JSONResponse({
-            "text": text,
-            "from_cache": False,
-            "message": "پردازش جدید انجام شد و در کش ذخیره شد"
-        })
+        else:
+            # فایل بزرگ - پردازش پس‌زمینه
+            add_processing_status(file_hash, file.filename, file_size, estimated_time)
+            
+            # شروع پردازش پس‌زمینه
+            background_tasks.add_task(background_transcription, tmp_file_path, file_hash, file.filename, file_size)
+            
+            return JSONResponse({
+                "status": "processing_started",
+                "estimated_time": estimated_time,
+                "file_hash": file_hash,
+                "message": f"پردازش شروع شد. حدود {estimated_time} دقیقه طول می‌کشد. می‌توانید بعدا نتیجه را بررسی کنید"
+            })
     
     except Exception as e:
         logger.error(f"Error in transcription: {str(e)}")
@@ -195,13 +374,47 @@ async def transcribe_audio(file: UploadFile = File(...)):
             raise HTTPException(status_code=500, detail=f"Processing error: {str(e)}")
     
     finally:
-        if tmp_file_path and os.path.exists(tmp_file_path):
+        # فقط فایل‌های کوچک را فوری پاک کن
+        if tmp_file_path and os.path.exists(tmp_file_path) and file_size < 5 * 1024 * 1024:
             try:
                 os.unlink(tmp_file_path)
                 logger.info(f"Temp file deleted: {tmp_file_path}")
             except:
                 pass
 
+@app.get("/status/{file_hash}")
+async def check_status(file_hash: str):
+    """بررسی وضعیت پردازش فایل"""
+    
+    # ابتدا چک کن نتیجه در کش هست یا نه
+    cached_result = get_from_cache(file_hash)
+    if cached_result:
+        remove_processing_status(file_hash)
+        return JSONResponse({
+            "status": "completed",
+            "text": cached_result,
+            "from_cache": True,
+            "message": "پردازش تکمیل شده و نتیجه آماده است"
+        })
+    
+    # بررسی وضعیت پردازش
+    processing_status = get_processing_status(file_hash)
+    if processing_status:
+        remaining_time = max(0, processing_status['estimated_time'] - processing_status['elapsed_minutes'])
+        return JSONResponse({
+            "status": processing_status['status'],
+            "progress": processing_status['progress'],
+            "elapsed_minutes": processing_status['elapsed_minutes'],
+            "estimated_time": processing_status['estimated_time'],
+            "remaining_time": remaining_time,
+            "message": f"در حال پردازش... حدود {remaining_time} دقیقه باقی مانده"
+        })
+    
+    return JSONResponse({
+        "status": "not_found",
+        "message": "فایل یافت نشد"
+    })
+
 @app.get("/cache/stats")
 async def cache_stats():
     try:
@@ -217,18 +430,19 @@ async def cache_stats():
         cursor.execute('SELECT AVG(LENGTH(transcription)) FROM cache')
         avg_text_length = cursor.fetchone()[0] or 0
         
+        cursor.execute('SELECT COUNT(*) FROM processing_status WHERE status = "processing"')
+        processing_count = cursor.fetchone()[0]
+        
         conn.close()
         
         return {
             "total_cached_files": total_count,
             "cached_today": today_count,
-            "average_text_length": int(avg_text_length)
+            "average_text_length": int(avg_text_length),
+            "currently_processing": processing_count
         }
     except Exception as e:
         return {"error": str(e)}
 
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860, timeout_keep_alive=900)
-
-if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860, timeout_keep_alive=300)
+    uvicorn.run(app, host="0.0.0.0", port=7860, timeout_keep_alive=900)