Update app.py

app.py

@@ -3,8 +3,7 @@ import sys
 import logging
 import warnings
 import torch
-import numpy as np
-from typing import Optional, Union, Dict
+from typing import Optional, Dict, Any
 
 # הגדרת logging
 logging.basicConfig(
@@ -13,140 +12,123 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-# התעלמות מאזהרות מיותרות
+# התעלמות מאזהרות לא רלוונטיות
 warnings.filterwarnings("ignore", category=UserWarning)
-warnings.filterwarnings("ignore", category=FutureWarning)
 
 try:
     import gradio as gr
     from pyannote.audio import Pipeline
 except ImportError as e:
-    logger.error(f"שגיאה בטעינת ספריות: {str(e)}")
+    logger.error(f"שגיאה בטעינת הספריות הנדרשות: {str(e)}")
     sys.exit(1)
 
-class DiarizationPipeline:
-    def __init__(self):
-        self.pipeline = None
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        logger.info(f"Using device: {self.device}")
-
-    def initialize(self) -> Optional[str]:
-        """מאתחל את הפייפליין עם טיפול שגיאות"""
-        try:
-            hf_token = os.getenv('HF_TOKEN')
-            if not hf_token:
-                return "חסר טוקן HF_TOKEN. אנא הגדר אותו בהגדרות."
-
-            self.pipeline = Pipeline.from_pretrained(
-                "pyannote/speaker-diarization@2.1",
-                use_auth_token=hf_token
-            )
-            
-            if self.device == "cuda":
-                self.pipeline = self.pipeline.to(torch.device("cuda"))
-            
-            return None  # אתחול הצליח
-            
-        except Exception as e:
-            error_msg = f"שגיאה באתחול המודל: {str(e)}"
-            logger.error(error_msg)
-            return error_msg
-
-    def process_audio(
-        self,
-        audio_path: str,
-        min_speakers: Optional[int] = None,
-        max_speakers: Optional[int] = None
-    ) -> Dict[str, Union[str, float, int]]:
-        """מעבד קובץ אודיו ומחזיר תוצאות מפורטות"""
-        
-        try:
-            if not os.path.exists(audio_path):
-                return {"error": "קובץ האודיו לא נמצא"}
-
-            file_size = os.path.getsize(audio_path) / (1024 * 1024)  # MB
-            if file_size > 100:  # הגבלת גודל קובץ
-                return {"error": f"גודל הקובץ ({file_size:.1f}MB) גדול מדי. המקסימום הוא 100MB"}
-
-            # וידוא שהפייפליין מאותחל
-            if self.pipeline is None:
-                init_error = self.initialize()
-                if init_error:
-                    return {"error": init_error}
-
-            # עיבוד האודיו
-            diarization = self.pipeline(
-                audio_path,
-                min_speakers=min_speakers if min_speakers and min_speakers > 0 else None,
-                max_speakers=max_speakers if max_speakers and max_speakers > 0 else None
-            )
+def initialize_pipeline() -> Optional[Pipeline]:
+    """אתחול מודל הדיאריזציה עם טיפול שגיאות"""
+    try:
+        hf_token = os.getenv('HF_TOKEN')
+        if not hf_token:
+            raise ValueError("לא נמצא HF_TOKEN במשתני הסביבה")
+
+        pipeline = Pipeline.from_pretrained(
+            "pyannote/[email protected]",
+            use_auth_token=hf_token
+        )
+
+        # העברה ל-GPU אם זמין
+        if torch.cuda.is_available():
+            pipeline = pipeline.to(torch.device("cuda"))
+            logger.info("המודל הועבר ל-GPU")
+        else:
+            logger.info("רץ על CPU")
 
-            # עיבוד התוצאות
-            segments = []
-            speakers = set()
-            total_duration = 0
-
-            for turn, _, speaker in diarization.itertracks(yield_label=True):
-                segment = {
-                    "start": turn.start,
-                    "end": turn.end,
-                    "duration": turn.duration,
-                    "speaker": speaker
-                }
-                segments.append(segment)
-                speakers.add(speaker)
-                total_duration += turn.duration
-
-            # יצירת פלט מעוצב
-            output_text = "תוצאות זיהוי הדוברים:\n\n"
-            
-            for segment in segments:
-                output_text += (
-                    f"[{segment['start']:.1f}s -> {segment['end']:.1f}s] "
-                    f"{segment['speaker']}\n"
-                )
-
-            # הוספת סטטיסטיקות
-            output_text += f"\nסיכום:\n"
-            output_text += f"מספר דוברים שזוהו: {len(speakers)}\n"
-            output_text += f"משך כולל: {total_duration:.1f} שניות\n"
-            output_text += f"גודל הקובץ: {file_size:.1f}MB\n"
-            
-            if min_speakers or max_speakers:
-                output_text += f"הגבלות שהוגדרו: "
-                if min_speakers:
-                    output_text += f"מינימום {min_speakers} דוברים, "
-                if max_speakers:
-                    output_text += f"מקסימום {max_speakers} דוברים"
-                output_text += "\n"
-
-            return {
-                "text": output_text,
-                "num_speakers": len(speakers),
-                "duration": total_duration,
-                "file_size": file_size,
-                "segments": segments
+        return pipeline
+
+    except Exception as e:
+        logger.error(f"שגיאה באתחול המודל: {str(e)}")
+        return None
+
+def process_audio(audio_path: str, min_speakers: int = None, max_speakers: int = None) -> Dict[str, Any]:
+    """עיבוד קובץ האודיו וזיהוי דוברים"""
+    try:
+        # בדיקות תקינות
+        if not audio_path or not os.path.exists(audio_path):
+            return {"error": "לא נבחר קובץ אודיו תקין"}
+
+        file_size_mb = os.path.getsize(audio_path) / (1024 * 1024)
+        if file_size_mb > 100:  # הגבלת גודל ל-100MB
+            return {"error": f"גודל הקובץ ({file_size_mb:.1f}MB) גדול מדי. המקסימום הוא 100MB"}
+
+        # אתחול המודל
+        pipeline = initialize_pipeline()
+        if pipeline is None:
+            return {"error": "שגיאה באתחול המודל"}
+
+        # הגדרת פרמטרים לזיהוי
+        diarization_options = {}
+        if min_speakers and min_speakers > 0:
+            diarization_options['min_speakers'] = min_speakers
+        if max_speakers and max_speakers > 0:
+            diarization_options['max_speakers'] = max_speakers
+
+        # זיהוי דוברים
+        diarization = pipeline(audio_path, **diarization_options)
+
+        # עיבוד התוצאות
+        results = []
+        speakers = set()
+        total_duration = 0
+
+        for turn, _, speaker in diarization.itertracks(yield_label=True):
+            segment = {
+                "start": turn.start,
+                "end": turn.end,
+                "duration": turn.duration,
+                "speaker": speaker
             }
+            results.append(segment)
+            speakers.add(speaker)
+            total_duration += turn.duration
+
+        # יצירת פלט מעוצב
+        output = [
+            "תוצאות זיהוי הדוברים:",
+            "=" * 30,
+            ""
+        ]
+
+        for segment in results:
+            output.append(
+                f"[{segment['start']:.1f}s -> {segment['end']:.1f}s] "
+                f"{segment['speaker']}"
+            )
 
-        except Exception as e:
-            error_msg = f"שגיאה בעיבוד האודיו: {str(e)}"
-            logger.error(error_msg)
-            return {"error": error_msg}
+        output.extend([
+            "",
+            "=" * 30,
+            "סיכום:",
+            f"• מספר דוברים שזוהו: {len(speakers)}",
+            f"• משך כולל: {total_duration:.1f} שניות",
+            f"• גודל הקובץ: {file_size_mb:.1f}MB",
+        ])
+
+        if min_speakers or max_speakers:
+            constraints = []
+            if min_speakers:
+                constraints.append(f"מינימום {min_speakers} דוברים")
+            if max_speakers:
+                constraints.append(f"מקסימום {max_speakers} דוברים")
+            output.append(f"• הגבלות: {', '.join(constraints)}")
+
+        return {"text": "\n".join(output)}
 
-# יצירת המעטפת לממשק משתמש
-def create_interface(pipeline: DiarizationPipeline) -> gr.Interface:
-    def process_wrapper(audio_path, min_speakers, max_speakers):
-        if audio_path is None:
-            return "לא נבחר קובץ אודיו"
-        
-        result = pipeline.process_audio(audio_path, min_speakers, max_speakers)
-        
-        if "error" in result:
-            return f"שגיאה: {result['error']}"
-        return result["text"]
+    except Exception as e:
+        logger.error(f"שגיאה בעיבוד האודיו: {str(e)}")
+        return {"error": f"שגיאה בעיבוד: {str(e)}"}
 
+def create_gradio_interface() -> gr.Interface:
+    """יצירת ממשק המשתמש"""
     return gr.Interface(
-        fn=process_wrapper,
+        fn=lambda audio, min_spk, max_spk: process_audio(audio, min_spk, max_spk).get("text", "שגיאה בעיבוד"),
         inputs=[
             gr.Audio(
                 label="קובץ אודיו",
@@ -155,13 +137,13 @@ def create_interface(pipeline: DiarizationPipeline) -> gr.Interface:
             ),
             gr.Number(
                 label="מינימום דוברים (אופציונלי)",
-                value=0,
+                value=None,
                 minimum=0,
                 step=1
             ),
             gr.Number(
                 label="מקסימום דוברים (אופציונלי)",
-                value=0,
+                value=None,
                 minimum=0,
                 step=1
             )
@@ -175,41 +157,40 @@ def create_interface(pipeline: DiarizationPipeline) -> gr.Interface:
         העלה קובץ אודיו לזיהוי הדוברים השונים והזמנים שלהם.
         
         הערות:
-        - תומך בפורמטים: WAV, MP3, FLAC
-        - גודל קובץ מקסימלי: 100MB
-        - מומלץ להשתמש בהקלטות באיכות טובה
-        - אם ידוע לך מספר הדוברים, הזן אותו לשיפור הדיוק
+        • תומך בפורמטים: WAV, MP3, FLAC
+        • גודל קובץ מקסימלי: 100MB
+        • מומלץ להשתמש בהקלטות באיכות טובה
+        • אם ידוע מספר הדוברים, ציון שלו יכול לשפר את הדיוק
+        """,
+        article="""
+        שים לב:
+        1. הזיהוי הכי מדויק בהקלטות ללא רעשי רקע
+        2. לפעמים המודל יכול לזהות את אותו דובר פעמיים
+        3. הזמנים מוצגים בשניות
         """,
         examples=[
             ["example.wav", 2, 4],
             ["interview.mp3", 2, 2]
-        ],
-        allow_flagging="never",
-        theme="default"
+        ]
     )
 
 if __name__ == "__main__":
     try:
-        # הדפסת מידע על הסביבה
+        # מידע על הסביבה
         logger.info(f"Python version: {sys.version}")
         logger.info(f"PyTorch version: {torch.__version__}")
-        logger.info(f"NumPy version: {np.__version__}")
         logger.info(f"Space ID: {os.getenv('SPACE_ID', 'unknown')}")
         logger.info(f"GPU available: {torch.cuda.is_available()}")
         
         if torch.cuda.is_available():
             logger.info(f"GPU model: {torch.cuda.get_device_name(0)}")
 
-        # יצירת הפייפליין והממשק
-        pipeline = DiarizationPipeline()
-        demo = create_interface(pipeline)
-        
-        # הפעלת הממשק
+        # יצירה והפעלת הממשק
+        demo = create_gradio_interface()
         demo.launch(
             share=True,
             enable_queue=True,
-            max_threads=4,
-            debug=True
+            max_threads=4
         )
         
     except Exception as e: