Update app.py

app.py

@@ -8,76 +8,79 @@ from fastapi.responses import JSONResponse
 from pyannote.audio import Pipeline
 import torch
 from pathlib import Path
-import librosa
 from datetime import datetime
 
-# קריאת טוקן מ-Secrets
+# קריאת טוכן מ-Secrets
 HF_TOKEN = os.getenv("HF_TOKEN")
 if not HF_TOKEN:
-    raise RuntimeError("❌ HF_TOKEN env var is required. Add it in Settings → Variables.")
+    raise RuntimeError("❌ HF_TOKEN environment variable is required")
 
 # טעינת המודל
 device = "cuda" if torch.cuda.is_available() else "cpu"
 print(f"🚀 Loading model on {device}...")
 
-pipeline = Pipeline.from_pretrained(
-    "ivrit-ai/pyannote-speaker-diarization-3.1",
-    token=HF_TOKEN,  # ✅ שונה מ-use_auth_token ל-token
-)
-pipeline.to(device)
-print("✅ Model loaded successfully!")
+try:
+    pipeline = Pipeline.from_pretrained(
+        "ivrit-ai/pyannote-speaker-diarization-3.1",
+        use_auth_token=HF_TOKEN,
+    )
+    pipeline.to(device)
+    print("✅ Model loaded successfully!")
+except Exception as e:
+    print(f"❌ Failed to load model: {e}")
+    raise
 
 app = FastAPI(
     title="Hebrew Speaker Diarization API",
-    description="API for Hebrew audio speaker diarization using pyannote.audio",
+    description="API for speaker diarization in Hebrew audio",
     version="1.0.0"
 )
 
-# 🔒 הגבלות
-MAX_FILE_SIZE_MB = 50  # מקסימום 50MB
-MAX_DURATION_MINUTES = 15  # מקסימום 15 דקות
-MAX_CONCURRENT_REQUESTS = 2  # מקסימום 2 בקשות במקביל
+# הגבלות
+MAX_FILE_SIZE_MB = 50
+MAX_DURATION_MINUTES = 15
+MAX_CONCURRENT_REQUESTS = 2
 
-# תור בקשות
+# ניהול תור
 processing_semaphore = asyncio.Semaphore(MAX_CONCURRENT_REQUESTS)
 active_requests = 0
 
 
 def ensure_wav_16k_mono(in_path: str) -> str:
-    """ממיר קובץ אודיו ל-WAV 16kHz mono"""
+    """ממיר אודיו ל-WAV 16kHz mono"""
     out_path = str(Path(in_path).with_suffix(".wav"))
     cmd = [
         "ffmpeg", "-y", "-i", in_path,
         "-ac", "1", "-ar", "16000",
+        "-loglevel", "error",
         out_path
     ]
     result = subprocess.run(cmd, capture_output=True, text=True)
     if result.returncode != 0:
-        raise RuntimeError(f"ffmpeg failed: {result.stderr}")
+        raise RuntimeError(f"FFmpeg conversion failed: {result.stderr}")
     return out_path
 
 
-def check_audio_duration(file_path: str) -> float:
-    """בדיקת אורך הקובץ"""
+def estimate_duration(file_path: str) -> float:
+    """אומדן אורך קובץ בדקות"""
     try:
-        # חישוב אורך לפי גודל קובץ
-        file_size = os.path.getsize(file_path)
-        # אומדן גס: 1 דקה אודיו ≈ 1-2 MB (תלוי בקידוד)
-        estimated_duration = file_size / (1024 * 1024) * 0.5  # דקות
-        return estimated_duration
+        file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
+        # אומדן: ~2MB לדקה (ממוצע)
+        return file_size_mb / 2.0
     except Exception:
         return 0
 
 
 @app.get("/")
 def root():
-    """נקודת כניסה ראשית - מידע על השירות"""
+    """מידע על ה-API"""
     global active_requests
     return {
         "service": "Hebrew Speaker Diarization API",
         "status": "running",
         "device": device,
         "model": "ivrit-ai/pyannote-speaker-diarization-3.1",
+        "version": "1.0.0",
         "limitations": {
             "max_file_size_mb": MAX_FILE_SIZE_MB,
             "max_duration_minutes": MAX_DURATION_MINUTES,
@@ -88,22 +91,23 @@ def root():
             "available_slots": MAX_CONCURRENT_REQUESTS - active_requests
         },
         "endpoints": {
-            "health": "/health",
-            "diarize": "/diarize (POST with audio file)"
+            "GET /": "This page",
+            "GET /health": "Health check",
+            "POST /diarize": "Upload audio file for diarization"
         }
     }
 
 
 @app.get("/health")
 def health():
-    """בדיקת בריאות השרת"""
+    """בדיקת בריאות"""
     global active_requests
     return {
         "status": "healthy",
         "device": device,
-        "model": "ivrit-ai/pyannote-speaker-diarization-3.1",
+        "model_loaded": True,
         "active_requests": active_requests,
-        "queue_available": active_requests < MAX_CONCURRENT_REQUESTS
+        "slots_available": MAX_CONCURRENT_REQUESTS - active_requests
     }
 
 
@@ -112,15 +116,14 @@ async def diarize(file: UploadFile = File(...)):
     """
     זיהוי דוברים בקובץ אודיו
     
-    Parameters:
-    - file: קובץ אודיו (MP3, WAV, M4A, וכו')
+    Args:
+        file: קובץ אודיו (MP3, WAV, M4A, וכו')
     
     Returns:
-    - JSON עם רשימת מקטעים לכל דובר
+        JSON: רשימת מקטעים עם זיהוי דוברים
     """
     global active_requests
     
-    file_size_mb = 0
     tmp_path = None
     wav_path = None
     
@@ -129,27 +132,27 @@ async def diarize(file: UploadFile = File(...)):
         content = await file.read()
         file_size_mb = len(content) / (1024 * 1024)
         
-        # בדיקת גודל קובץ
+        # בדיקת גודל
         if file_size_mb > MAX_FILE_SIZE_MB:
             raise HTTPException(
                 status_code=400,
-                detail=f"❌ קובץ גדול מדי: {file_size_mb:.1f}MB. מקסימום: {MAX_FILE_SIZE_MB}MB"
+                detail=f"File too large: {file_size_mb:.1f}MB (max: {MAX_FILE_SIZE_MB}MB)"
             )
         
         # בדיקת תור
         if active_requests >= MAX_CONCURRENT_REQUESTS:
             raise HTTPException(
                 status_code=503,
-                detail=f"⏳ השרת עמוס ({active_requests}/{MAX_CONCURRENT_REQUESTS} בקשות פעילות). נסה שוב בעוד דקה."
+                detail=f"Server busy ({active_requests}/{MAX_CONCURRENT_REQUESTS} active). Try again later."
             )
         
-        # נעילת slot
+        # עיבוד
         async with processing_semaphore:
             active_requests += 1
             
             try:
                 # שמירה זמנית
-                suffix = Path(file.filename).suffix or ".bin"
+                suffix = Path(file.filename).suffix or ".tmp"
                 with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
                     tmp.write(content)
                     tmp_path = tmp.name
@@ -157,53 +160,59 @@ async def diarize(file: UploadFile = File(...)):
                 # המרה ל-WAV
                 wav_path = ensure_wav_16k_mono(tmp_path)
                 
-                # בדיקת אורך
-                duration = check_audio_duration(wav_path)
+                # אומדן אורך
+                duration = estimate_duration(wav_path)
                 if duration > MAX_DURATION_MINUTES:
                     raise HTTPException(
                         status_code=400,
-                        detail=f"❌ קובץ ארוך מדי: ~{duration:.1f} דקות. מקסימום: {MAX_DURATION_MINUTES} דקות"
+                        detail=f"File too long: ~{duration:.1f} min (max: {MAX_DURATION_MINUTES} min)"
                     )
                 
-                # עיבוד בפועל
-                print(f"🎤 Processing: {file.filename} ({file_size_mb:.1f}MB, ~{duration:.1f}min)")
+                # זיהוי דוברים
+                print(f"🎤 Processing: {file.filename} ({file_size_mb:.1f}MB)")
                 start_time = datetime.now()
                 
                 annotation = pipeline(wav_path)
                 
                 processing_time = (datetime.now() - start_time).total_seconds()
-                print(f"✅ Completed in {processing_time:.1f}s")
+                print(f"✅ Done in {processing_time:.1f}s")
                 
-                # איחוד מקטעים רציפים של אותו דובר
+                # בניית תוצאות
                 segments = []
-                last = None
+                last_segment = None
                 
                 for segment, _, speaker in annotation.itertracks(yield_label=True):
                     start = round(float(segment.start), 3)
                     end = round(float(segment.end), 3)
-                    spk = str(speaker)
+                    speaker_id = str(speaker)
                     
                     # איחוד מקטעים צמודים של אותו דובר
-                    if last and last["speaker"] == spk and abs(start - last["end"]) < 0.05:
-                        last["end"] = end
+                    if (last_segment and 
+                        last_segment["speaker"] == speaker_id and 
+                        abs(start - last_segment["end"]) < 0.1):
+                        last_segment["end"] = end
                     else:
-                        if last:
-                            segments.append(last)
-                        last = {"speaker": spk, "start": start, "end": end}
+                        if last_segment:
+                            segments.append(last_segment)
+                        last_segment = {
+                            "speaker": speaker_id,
+                            "start": start,
+                            "end": end
+                        }
                 
-                if last:
-                    segments.append(last)
+                if last_segment:
+                    segments.append(last_segment)
                 
-                # סינון מקטעים קצרים מדי (פחות מ-0.2 שניות)
-                cleaned = [s for s in segments if s["end"] - s["start"] >= 0.2]
+                # סינון מקטעים קצרים
+                segments = [s for s in segments if s["end"] - s["start"] >= 0.2]
                 
                 return JSONResponse({
                     "success": True,
-                    "file": file.filename,
+                    "filename": file.filename,
                     "file_size_mb": round(file_size_mb, 2),
                     "processing_time_seconds": round(processing_time, 1),
-                    "segments": cleaned,
-                    "total_speakers": len(set(s["speaker"] for s in cleaned))
+                    "total_speakers": len(set(s["speaker"] for s in segments)),
+                    "segments": segments
                 })
                 
             finally:
@@ -211,12 +220,11 @@ async def diarize(file: UploadFile = File(...)):
                 
     except HTTPException:
         raise
-    except subprocess.CalledProcessError as e:
-        raise HTTPException(status_code=400, detail=f"❌ שגיאת המרה: {str(e)}")
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"❌ שגיאת עיבוד: {str(e)}")
+        print(f"❌ Error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Processing error: {str(e)}")
     finally:
-        # ניקוי קבצים זמניים
+        # ניקוי
         for path in [tmp_path, wav_path]:
             if path and os.path.exists(path):
                 try: