Update app.py

app.py

@@ -13,8 +13,7 @@ from concurrent.futures import ThreadPoolExecutor
 # Setup logging
 logging.basicConfig(
     level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 logging.getLogger("nemo_logging").setLevel(logging.ERROR)
 logging.getLogger("nemo").setLevel(logging.ERROR)
@@ -27,7 +26,6 @@ os.makedirs(OUTPUT_DIR, exist_ok=True)
 VALID_EXTENSIONS = ('.wav', '.mp3', '.m4a', '.flac')
 MAX_FILE_SIZE = 300 * 1024 * 1024  # 300MB
 
-
 def check_health() -> str:
     """Check system health, similar to FastAPI /health endpoint"""
     try:
@@ -39,42 +37,39 @@ def check_health() -> str:
         logger.error(f"Health check failed: {str(e)}")
         return f"System is unhealthy: {str(e)}"
 
-
 # A helper function to process a single audio file
 def process_single_audio(file_path_or_url: str) -> Dict:
     """Processes a single audio file and returns its analysis."""
     try:
         if not file_path_or_url:
             return {"error": "No audio provided for processing."}
-
-        # Gradio will download the file if it's a URL and provide a local path.
-        # So, 'file_path_or_url' will always be a local path when it reaches this function.
+        
         temp_audio_path = Path(file_path_or_url)
-
         file_ext = temp_audio_path.suffix.lower()
+        
         if file_ext not in VALID_EXTENSIONS:
             return {"error": f"Invalid file format: {file_ext}. Supported formats: {', '.join(VALID_EXTENSIONS)}"}
-
+        
         file_size = os.path.getsize(temp_audio_path)
         if file_size > MAX_FILE_SIZE:
             return {
                 "error": f"File too large: {file_size / (1024 * 1024):.2f}MB. Max size: {MAX_FILE_SIZE // (1024 * 1024)}MB"}
-
+        
         logger.info(f"Processing audio from: {temp_audio_path}")
         result = process_interview(str(temp_audio_path))
-
+        
         if not result or 'pdf_path' not in result or 'json_path' not in result:
             return {"error": "Processing failed - invalid result format."}
-
+        
         pdf_path = Path(result['pdf_path'])
         json_path = Path(result['json_path'])
-
+        
         if not pdf_path.exists() or not json_path.exists():
             return {"error": "Processing failed - output files not found."}
-
+        
         with json_path.open('r') as f:
             analysis_data = json.load(f)
-
+            
         voice_analysis = analysis_data.get('voice_analysis', {})
         summary = (
             f"Speakers: {', '.join(analysis_data['speakers'])}\n"
@@ -82,21 +77,18 @@ def process_single_audio(file_path_or_url: str) -> Dict:
             f"Confidence Level: {voice_analysis.get('interpretation', {}).get('confidence_level', 'Unknown')}\n"
             f"Anxiety Level: {voice_analysis.get('interpretation', {}).get('anxiety_level', 'Unknown')}"
         )
-
         json_data = json.dumps(analysis_data, indent=2)
-
+        
         return {
             "summary": summary,
             "json_data": json_data,
             "pdf_path": str(pdf_path),
-            "original_input": file_path_or_url  # Optionally return the original URL/path for mapping
+            "original_input": file_path_or_url
         }
-
     except Exception as e:
         logger.error(f"Error processing single audio: {str(e)}", exc_info=True)
         return {"error": f"Error during processing: {str(e)}"}
 
-
 # Main function to handle multiple audio files/URLs
 def analyze_multiple_audios(file_paths_or_urls: List[str]) -> Tuple[str, str, List[str]]:
     """
@@ -105,23 +97,19 @@ def analyze_multiple_audios(file_paths_or_urls: List[str]) -> Tuple[str, str, Li
     """
     if not file_paths_or_urls:
         return "No audio files/URLs provided.", "[]", []
-
+    
     all_summaries = []
     all_json_data = []
     all_pdf_paths = []
 
-    # Use ThreadPoolExecutor for parallel processing
-    # Adjust max_workers based on available resources and expected load
     with ThreadPoolExecutor(max_workers=5) as executor:
         futures = {executor.submit(process_single_audio, item): item for item in file_paths_or_urls}
-
         for future in futures:
-            item = futures[future]  # Get the original item (URL/path) that was processed
+            item = futures[future]
             try:
-                result = future.result()  # Get the result of the processing
+                result = future.result()
                 if "error" in result:
                     all_summaries.append(f"Error processing {item}: {result['error']}")
-                    # Include error in JSON output for clarity
                     all_json_data.append(json.dumps({"input": item, "error": result['error']}, indent=2))
                 else:
                     all_summaries.append(f"Analysis for {os.path.basename(item)}:\n{result['summary']}")
@@ -131,14 +119,12 @@ def analyze_multiple_audios(file_paths_or_urls: List[str]) -> Tuple[str, str, Li
                 logger.error(f"Item {item} generated an unexpected exception: {exc}", exc_info=True)
                 all_summaries.append(f"Error processing {item}: An unexpected error occurred.")
                 all_json_data.append(json.dumps({"input": item, "error": str(exc)}, indent=2))
-
+                
     combined_summary = "\n\n---\n\n".join(all_summaries)
-    # Ensure the combined_json_list is a valid JSON array string
     combined_json_list = "[\n" + ",\n".join(all_json_data) + "\n]"
-
+    
     return combined_summary, combined_json_list, all_pdf_paths
 
-
 # Gradio interface
 with gr.Blocks(title="EvalBot Interview Analysis System", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
@@ -146,17 +132,15 @@ with gr.Blocks(title="EvalBot Interview Analysis System", theme=gr.themes.Soft()
     Provide multiple audio file URLs or upload multiple audio files to analyze speaker performance.  
     Supported formats: WAV, MP3, M4A, FLAC (max 300MB per file).
     """)
-
     with gr.Row():
         with gr.Column():
             health_status = gr.Textbox(label="System Status", value=check_health(), interactive=False)
             audio_inputs = gr.File(
                 label="Provide Audio URLs or Upload Files (Multiple allowed)",
-                type="filepath",  # هذا يسمح بـ URLs
-                file_count="multiple"  # السماح بأكثر من URL/ملف
+                type="filepath",
+                file_count="multiple"
             )
             submit_btn = gr.Button("Start Analysis", variant="primary")
-
         with gr.Column():
             output_summary = gr.Textbox(label="Combined Analysis Summary", interactive=False, lines=10)
             output_json = gr.Textbox(label="Detailed Analysis (JSON Array)", interactive=False, lines=20)
@@ -165,7 +149,8 @@ with gr.Blocks(title="EvalBot Interview Analysis System", theme=gr.themes.Soft()
     submit_btn.click(
         fn=analyze_multiple_audios,
         inputs=audio_inputs,
-        outputs=[output_summary, output_json, pdf_outputs]
+        outputs=[output_summary, output_json, pdf_outputs],
+        api_name="analyze_multiple_audios"  # <-- هذا هو السطر الجديد والمهم
     )
 
 # Run the interface