Update app.py

app.py

@@ -1,32 +1,43 @@
-from fastapi import FastAPI, HTTPException, Body
-from pydantic import BaseModel, HttpUrl
 import os
 import uuid
 import shutil
 import json
 import requests
-from process_interview import process_interview
+import logging
+
+from fastapi import FastAPI, HTTPException, Body
 from fastapi.staticfiles import StaticFiles
 from fastapi.responses import FileResponse
+from pydantic import BaseModel, HttpUrl
+from process_interview import process_interview
+
+# Setup Logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("EvalBot-Audio-Processor")
 
+# Initialize App
 app = FastAPI()
 
-TEMP_DIR = "./temp_files"
-OUTPUT_DIR = "./static/outputs"
+# Directories setup
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+TEMP_DIR = os.path.join(BASE_DIR, "temp_files")
+STATIC_DIR = os.path.join(BASE_DIR, "static")
+OUTPUT_DIR = os.path.join(STATIC_DIR, "outputs")
 JSON_DIR = os.path.join(OUTPUT_DIR, "json")
 PDF_DIR = os.path.join(OUTPUT_DIR, "pdf")
 
-os.makedirs(TEMP_DIR, exist_ok=True)
-os.makedirs(JSON_DIR, exist_ok=True)
-os.makedirs(PDF_DIR, exist_ok=True)
+for folder in [TEMP_DIR, JSON_DIR, PDF_DIR]:
+    os.makedirs(folder, exist_ok=True)
 
-app.mount("/static", StaticFiles(directory="static"), name="static")
+# Mount static files for serving output files
+app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
 
+# Configurations
 VALID_EXTENSIONS = ('.wav', '.mp3', '.m4a', '.flac')
 MAX_FILE_SIZE_MB = 300
-
 BASE_URL = os.getenv("BASE_URL", "https://evalbot-audio-evalbot.hf.space")
 
+# Request and Response models
 class ProcessResponse(BaseModel):
     summary: str
     json_url: str
@@ -36,42 +47,59 @@ class ProcessAudioRequest(BaseModel):
     file_url: HttpUrl
     user_id: str
 
+# Helper functions
+def download_file(file_url: str, dest_path: str):
+    logger.info(f"Downloading file from {file_url}")
+    try:
+        resp = requests.get(file_url, stream=True, timeout=60)
+        resp.raise_for_status()
+        with open(dest_path, "wb") as f:
+            for chunk in resp.iter_content(chunk_size=8192):
+                if chunk:
+                    f.write(chunk)
+    except Exception as e:
+        logger.error(f"Error downloading file: {e}")
+        raise HTTPException(status_code=400, detail="Failed to download file")
+
+def validate_file_size(file_path: str):
+    file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
+    if file_size_mb > MAX_FILE_SIZE_MB:
+        logger.warning(f"File too large: {file_size_mb} MB")
+        os.remove(file_path)
+        raise HTTPException(status_code=400, detail=f"File too large: {file_size_mb:.2f} MB")
+
+def generate_public_url(sub_path: str) -> str:
+    return f"{BASE_URL}/static/{sub_path}"
+
+# Main endpoint
 @app.post("/process-audio", response_model=ProcessResponse)
 async def process_audio(request: ProcessAudioRequest = Body(...)):
-    file_url = request.file_url
+    file_url = str(request.file_url)
     user_id = request.user_id
-    try:
-        file_ext = os.path.splitext(str(file_url))[1].lower()
-        if file_ext not in VALID_EXTENSIONS:
-            raise HTTPException(status_code=400, detail=f"Invalid file extension: {file_ext}")
 
-        local_filename = f"{user_id}_{uuid.uuid4().hex}{file_ext}"
-        local_path = os.path.join(TEMP_DIR, local_filename)
+    file_ext = os.path.splitext(file_url)[1].lower()
+    if file_ext not in VALID_EXTENSIONS:
+        logger.error("Invalid file extension")
+        raise HTTPException(status_code=400, detail=f"Invalid file extension: {file_ext}")
 
-        resp = requests.get(str(file_url), stream=True, timeout=30)
-        if resp.status_code != 200:
-            raise HTTPException(status_code=400, detail="Could not download the file from URL")
+    temp_filename = f"{user_id}_{uuid.uuid4().hex}{file_ext}"
+    temp_path = os.path.join(TEMP_DIR, temp_filename)
 
-        with open(local_path, "wb") as f:
-            for chunk in resp.iter_content(chunk_size=8192):
-                if chunk:
-                    f.write(chunk)
+    try:
+        download_file(file_url, temp_path)
+        validate_file_size(temp_path)
 
-        file_size_mb = os.path.getsize(local_path) / (1024 * 1024)
-        if file_size_mb > MAX_FILE_SIZE_MB:
-            os.remove(local_path)
-            raise HTTPException(status_code=400, detail=f"File too large: {file_size_mb:.2f} MB")
+        logger.info("Processing interview")
+        result = process_interview(temp_path)
 
-        result = process_interview(local_path)
         if not result:
-            os.remove(local_path)
             raise HTTPException(status_code=500, detail="Processing failed")
 
-        json_dest_name = f"{user_id}_{uuid.uuid4().hex}.json"
-        pdf_dest_name = f"{user_id}_{uuid.uuid4().hex}.pdf"
+        json_filename = f"{user_id}_{uuid.uuid4().hex}.json"
+        pdf_filename = f"{user_id}_{uuid.uuid4().hex}.pdf"
 
-        json_dest = os.path.join(JSON_DIR, json_dest_name)
-        pdf_dest = os.path.join(PDF_DIR, pdf_dest_name)
+        json_dest = os.path.join(JSON_DIR, json_filename)
+        pdf_dest = os.path.join(PDF_DIR, pdf_filename)
 
         shutil.copyfile(result['json_path'], json_dest)
         shutil.copyfile(result['pdf_path'], pdf_dest)
@@ -91,17 +119,22 @@ async def process_audio(request: ProcessAudioRequest = Body(...)):
             f"Anxiety: {voice.get('anxiety_level', 'N/A')}"
         )
 
-        json_url = f"{BASE_URL}/outputs/json/{json_dest_name}"
-        pdf_url = f"{BASE_URL}/outputs/pdf/{pdf_dest_name}"
-
-        os.remove(local_path)
+        json_url = generate_public_url(f"outputs/json/{json_filename}")
+        pdf_url = generate_public_url(f"outputs/pdf/{pdf_filename}")
 
+        logger.info("Processing completed successfully")
         return ProcessResponse(summary=summary, json_url=json_url, pdf_url=pdf_url)
 
+    except HTTPException as e:
+        raise e
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
+        logger.exception("Unexpected error during processing")
+        raise HTTPException(status_code=500, detail="Internal server error")
+    finally:
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
 
+# Serve output files
 @app.get("/outputs/json/{filename}")
 async def get_json_file(filename: str):
     file_path = os.path.join(JSON_DIR, filename)