Update app.py

app.py

@@ -1,101 +1,68 @@
+from flask import Flask, request, jsonify, send_file
 import os
 import uuid
-import logging
+import requests
 import json
-import shutil
-from pathlib import Path
-import tempfile
-import gradio as gr
 from process_interview import process_interview
-from typing import Tuple, Optional, List, Dict
-from concurrent.futures import ThreadPoolExecutor
-import requests
-logging.basicConfig(level=logging.INFO)
+from urllib.parse import urlparse
 
-# إعداد مجلد مؤقت للتحميل
-TEMP_DIR = "./temp_files"
-os.makedirs(TEMP_DIR, exist_ok=True)
+app = Flask(__name__)
 
-VALID_EXTENSIONS = ('.wav', '.mp3', '.m4a', '.flac')
-MAX_FILE_SIZE_MB = 300
+# Create folders to store the files
+OUTPUT_DIR = "./processed_audio"
+os.makedirs(OUTPUT_DIR, exist_ok=True)
 
-# Health check
-def check_health() -> str:
+@app.route("/process-audio", methods=["POST"])
+def process_audio():
     try:
-        if not os.path.exists(TEMP_DIR):
-            os.makedirs(TEMP_DIR)
-        return "System is healthy"
-    except Exception as e:
-        logging.error(f"Health check failed: {e}")
-        return "System unhealthy"
+        data = request.json
+        user_id = data.get("user_id")
+        audio_url = data.get("audio_url")
 
-# Main Processing Function
-def process_audio(file_url: str, user_id: str) -> Tuple[str, str, str]:
-    try:
-        # تحميل الملف
-        filename = f"{user_id}_{os.path.basename(file_url)}"
-        local_path = os.path.join(TEMP_DIR, filename)
+        if not user_id or not audio_url:
+            return jsonify({"error": "Missing user_id or audio_url"}), 400
 
-        logging.info(f"Downloading file: {file_url}")
-        response = requests.get(file_url, stream=True)
-        with open(local_path, 'wb') as f:
-            for chunk in response.iter_content(chunk_size=8192):
-                f.write(chunk)
+        # Generate unique filename per user
+        file_ext = os.path.splitext(urlparse(audio_url).path)[1]
+        filename = f"{user_id}_{uuid.uuid4()}{file_ext}"
+        local_file_path = os.path.join(OUTPUT_DIR, filename)
 
-        # التحقق من الامتداد والحجم
-        file_ext = Path(local_path).suffix.lower()
-        if file_ext not in VALID_EXTENSIONS:
-            return f"❌ Invalid file type: {file_ext}", "", ""
+        # Download the audio file
+        response = requests.get(audio_url, stream=True)
+        if response.status_code != 200:
+            return jsonify({"error": "Failed to download audio file"}), 400
 
-        file_size_mb = os.path.getsize(local_path) / (1024 * 1024)
-        if file_size_mb > MAX_FILE_SIZE_MB:
-            return f"❌ File too large: {file_size_mb:.2f}MB", "", ""
+        with open(local_file_path, "wb") as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                f.write(chunk)
 
-        # بدء المعالجة
-        result = process_interview(local_path)
-        if not result:
-            return "❌ Processing failed.", "", ""
+        # Call your processing pipeline
+        result = process_interview(local_file_path)
 
-        pdf_path = result['pdf_path']
-        with open(result['json_path'], 'r') as f:
-            analysis_data = json.load(f)
+        if not result or 'pdf_path' not in result or 'json_path' not in result:
+            return jsonify({"error": "Processing failed"}), 500
 
-        # بناء الـ Summary
-        voice = analysis_data['voice_analysis']['interpretation']
-        summary = (
-            f"User ID: {user_id}\n"
-            f"Speakers: {', '.join(analysis_data['speakers'])}\n"
-            f"Duration: {analysis_data['text_analysis']['total_duration']:.2f} sec\n"
-            f"Confidence: {voice['confidence_level']}\n"
-            f"Anxiety: {voice['anxiety_level']}"
-        )
+        # Return file URLs (assuming you deploy this API somewhere publicly)
+        server_url = request.host_url.rstrip('/')
+        pdf_url = f"{server_url}/download?file={os.path.basename(result['pdf_path'])}"
+        json_url = f"{server_url}/download?file={os.path.basename(result['json_path'])}"
 
-        json_data = json.dumps(analysis_data, indent=2)
-        return summary, json_data, pdf_path
+        return jsonify({
+            "message": "Processing complete",
+            "pdf_url": pdf_url,
+            "json_url": json_url
+        })
 
     except Exception as e:
-        logging.error(f"Error processing audio: {e}", exc_info=True)
-        return f"❌ Internal Error: {str(e)}", "", ""
-
-# Gradio Interface
-with gr.Blocks(title="EvalBot Audio Analysis") as demo:
-    gr.Markdown("# 🎙️ EvalBot Audio Analysis (Single URL Mode)")
-
-    file_url = gr.Textbox(label="Audio File URL (single)")
-    user_id = gr.Textbox(label="User ID")
-
-    analyze_btn = gr.Button("Analyze Audio")
-
-    output_summary = gr.Textbox(label="Summary")
-    output_json = gr.Textbox(label="JSON Output")
-    output_pdf = gr.Textbox(label="PDF Path")
+        return jsonify({"error": str(e)}), 500
 
-    analyze_btn.click(
-        fn=process_audio,
-        inputs=[file_url, user_id],
-        outputs=[output_summary, output_json, output_pdf],
-        api_name="analyze_single_audio"
-    )
+@app.route("/download", methods=["GET"])
+def download_file():
+    filename = request.args.get("file")
+    file_path = os.path.join(OUTPUT_DIR, filename)
+    if not os.path.exists(file_path):
+        return jsonify({"error": "File not found"}), 404
+    return send_file(file_path, as_attachment=True)
 
 if __name__ == "__main__":
-    demo.launch(server_port=7860, server_name="0.0.0.0")
+    app.run(host="0.0.0.0", port=5000)