Update app.py

app.py

@@ -1,137 +1,83 @@
-
-
+norhan shalaby, [6/12/2025 7:24 AM]
+from fastapi import FastAPI, HTTPException, Body
+from pydantic import BaseModel, HttpUrl
 import os
 import uuid
 import shutil
 import json
-from fastapi import FastAPI, HTTPException, Query
-from fastapi.responses import JSONResponse, FileResponse
-from pydantic import BaseModel
 import requests
-from process_interview import process_interview  # Ensure process_interview function is available
-
+from process_interview import process_interview
 from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
 
-# Initialize FastAPI app
 app = FastAPI()
 
-# --- Directory Setup ---
-BASE_DIR = os.path.dirname(os.path.abspath(__file__)) # Get the directory of the current script
-TEMP_DIR = os.path.join(BASE_DIR, "temp_files") # Temporary storage for downloaded audio files
-STATIC_DIR = os.path.join(BASE_DIR, "static") # Root directory for all static assets
-OUTPUT_DIR = os.path.join(STATIC_DIR, "outputs") # Subdirectory within static for generated reports
+TEMP_DIR = "./temp_files"
+OUTPUT_DIR = "./static/outputs"
+JSON_DIR = os.path.join(OUTPUT_DIR, "json")
+PDF_DIR = os.path.join(OUTPUT_DIR, "pdf")
 
-# Create directories if they don't exist
 os.makedirs(TEMP_DIR, exist_ok=True)
-os.makedirs(OUTPUT_DIR, exist_ok=True)
+os.makedirs(JSON_DIR, exist_ok=True)
+os.makedirs(PDF_DIR, exist_ok=True)
 
-# Mount the 'static' directory to be served at the '/static' URL path.
-# This means files in ./static/outputs/filename will be accessible at /static/outputs/filename
-app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
+app.mount("/static", StaticFiles(directory="static"), name="static")
 
-# --- Configuration Constants ---
 VALID_EXTENSIONS = ('.wav', '.mp3', '.m4a', '.flac')
 MAX_FILE_SIZE_MB = 300
 
-# BASE_URL should be the root URL of your deployed application.
-# Example: "https://evalbot-audio-evalbot.hf.space" when deployed on Hugging Face.
-# Example: "http://localhost:8000" when running locally with Uvicorn.
-# It should NOT include "/static" or any subpaths.
 BASE_URL = os.getenv("BASE_URL", "https://evalbot-audio-evalbot.hf.space")
 
-# --- Pydantic Models ---
 class ProcessResponse(BaseModel):
-    """
-    Defines the structure of the response returned by the /process-audio endpoint.
-    Includes a summary of the analysis and public URLs to the detailed JSON and PDF reports.
-    """
     summary: str
     json_url: str
     pdf_url: str
 
-# --- Helper Function for URL Generation ---
-def generate_public_output_url(filename: str, file_type: str) -> str:
-    """
-    Constructs a public URL for a generated output file (JSON or PDF).
-    The files are stored in STATIC_DIR/outputs/.
-    """
-    # The path relative to the mounted /static directory will be "outputs/json/filename" or "outputs/pdf/filename"
-    # We join it directly to BASE_URL/static/
-    return f"{BASE_URL}/static/outputs/{file_type}/{filename}"
-
-# --- API Endpoints ---
-@app.get("/")
-async def root():
-    """
-    Root endpoint for the API. Returns a simple message to confirm the API is running.
-    """
-    return {"message": "EvalBot API is running"}
+class ProcessAudioRequest(BaseModel):
+    file_url: HttpUrl
+    user_id: str
 
 @app.post("/process-audio", response_model=ProcessResponse)
-async def process_audio(
-    file_url: str = Query(..., description="URL of the audio file to be processed"),
-    user_id: str = Query(..., description="Unique identifier for the user")
-):
-    """
-    Main endpoint to process an audio file.
-    Downloads the audio, performs interview analysis using `process_interview`,
-    saves the generated reports, and returns their public URLs.
-    """
+async def process_audio(request: ProcessAudioRequest = Body(...)):
+    file_url = request.file_url
+    user_id = request.user_id
     try:
-        # Validate audio file extension
-        file_ext = os.path.splitext(file_url)[1].lower()
+        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}. Supported: {', '.join(VALID_EXTENSIONS)}")
+            raise HTTPException(status_code=400, detail=f"Invalid file extension: {file_ext}")
 
-        # Generate a unique temporary filename for the downloaded audio
         local_filename = f"{user_id}_{uuid.uuid4().hex}{file_ext}"
         local_path = os.path.join(TEMP_DIR, local_filename)
 
-        # Download the audio file from the provided URL
-        try:
-            resp = requests.get(file_url, stream=True, timeout=30)
-            resp.raise_for_status() # Raises an HTTPError for bad responses (4xx or 5xx)
-            with open(local_path, "wb") as f:
-                for chunk in resp.iter_content(chunk_size=8192):
-                    if chunk: # Write only non-empty chunks
-                        f.write(chunk)
-        except requests.exceptions.RequestException as e:
-            raise HTTPException(status_code=400, detail=f"Failed to download the file from URL: {e}")
-
-        # Validate the size of the downloaded file
+        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")
+
+        with open(local_path, "wb") as f:
+            for chunk in resp.iter_content(chunk_size=8192):
+                if chunk:
+                    f.write(chunk)
+
         file_size_mb = os.path.getsize(local_path) / (1024 * 1024)
         if file_size_mb > MAX_FILE_SIZE_MB:
-            os.remove(local_path) # Clean up the oversized file
-            raise HTTPException(status_code=400, detail=f"File too large: {file_size_mb:.2f} MB. Max allowed: {MAX_FILE_SIZE_MB} MB")
+            os.remove(local_path)
+            raise HTTPException(status_code=400, detail=f"File too large: {file_size_mb:.2f} MB")
 
-        # Process the interview audio using the `process_interview` module
         result = process_interview(local_path)
         if not result:
-            os.remove(local_path) # Clean up temporary audio file
-            raise HTTPException(status_code=500, detail="Audio processing failed: `process_interview` returned no result.")
-
-        # Get the source paths of the generated JSON and PDF reports from `process_interview`
-        json_src_path = result['json_path']
-        pdf_src_path = result['pdf_path']
+            os.remove(local_path)
+            raise HTTPException(status_code=500, detail="Processing failed")
 
-        # Generate unique destination filenames for the reports within the public 'static/outputs' directory
         json_dest_name = f"{user_id}_{uuid.uuid4().hex}.json"
         pdf_dest_name = f"{user_id}_{uuid.uuid4().hex}.pdf"
 
-        # Define the full destination paths for copying the reports
-        json_dest_full_path = os.path.join(OUTPUT_DIR, "json", json_dest_name) # Ensure sub-folders
-        pdf_dest_full_path = os.path.join(OUTPUT_DIR, "pdf", pdf_dest_name)   # Ensure sub-folders
+        json_dest = os.path.join(JSON_DIR, json_dest_name)
+        pdf_dest = os.path.join(PDF_DIR, pdf_dest_name)
 
-        # Create subdirectories if they don't exist
-        os.makedirs(os.path.dirname(json_dest_full_path), exist_ok=True)
-        os.makedirs(os.path.dirname(pdf_dest_full_path), exist_ok=True)
-        
-        # Copy the generated reports to their final public locations
-        shutil.copyfile(json_src_path, json_dest_full_path)
-        shutil.copyfile(pdf_src_path, pdf_dest_full_path)
+        shutil.copyfile(result['json_path'], json_dest)
+        shutil.copyfile(result['pdf_path'], pdf_dest)
 
-        # Read analysis data from the JSON report to create the summary for the response
-        with open(json_src_path, "r") as jf: # Read from the source path, as it's guaranteed to be complete
+        with open(result['json_path'], "r") as jf:
             analysis_data = json.load(jf)
 
         voice = analysis_data.get('voice_analysis', {}).get('interpretation', {})
@@ -146,47 +92,28 @@ async def process_audio(
             f"Anxiety: {voice.get('anxiety_level', 'N/A')}"
         )
 
-        # Generate the public URLs using the helper function
-        json_url = generate_public_output_url(json_dest_name, "json")
-        pdf_url = generate_public_output_url(pdf_dest_name, "pdf")
+        json_url = f"{BASE_URL}/outputs/json/{json_dest_name}"
+        pdf_url = f"{BASE_URL}/outputs/pdf/{pdf_dest_name}"
 
-        # Clean up the temporary downloaded audio file
         os.remove(local_path)
 
         return ProcessResponse(summary=summary, json_url=json_url, pdf_url=pdf_url)
 
-    except HTTPException as e:
-        # Re-raise explicit HTTPExceptions (e.g., 400 for bad requests)
-        raise e
     except Exception as e:
-        # Catch any other unexpected errors and return a 500 Internal Server Error
-        # Log the full traceback for debugging
-        import traceback
-        traceback.print_exc()
-        raise HTTPException(status_code=500, detail=f"An internal server error occurred: {str(e)}")
-
-# --- GET Endpoints for Direct File Access ---
-# These endpoints allow direct access to the generated JSON and PDF reports.
-# The URL paths are designed to match how files are mounted by StaticFiles.
-
-@app.get("/static/outputs/json/{filename}")
-async def get_json_report(filename: str):
-    """
-    Serves a JSON analysis file directly from the 'static/outputs/json' directory.
-    Example URL: https://evalbot-audio-evalbot.hf.space/static/outputs/json/candidate-123_uuid.json
-    """
-    file_path = os.path.join(OUTPUT_DIR, "json", filename) # Construct full path
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/outputs/json/{filename}")
+async def get_json_file(filename: str):
+    file_path = os.path.join(JSON_DIR, filename)
     if not os.path.exists(file_path):
         raise HTTPException(status_code=404, detail="JSON file not found")
     return FileResponse(file_path, media_type="application/json", filename=filename)
 
-@app.get("/static/outputs/pdf/{filename}")
-async def get_pdf_report(filename: str):
-    """
-    Serves a PDF report file directly from the 'static/outputs/pdf' directory.
-    Example URL: https://evalbot-audio-evalbot.hf.space/static/outputs/pdf/candidate-123_uuid.pdf
-    """
-    file_path = os.path.join(OUTPUT_DIR, "pdf", filename) # Construct full path
+norhan shalaby, [6/12/2025 7:24 AM]
+@app.get("/outputs/pdf/{filename}")
+async def get_pdf_file(filename: str):
+    file_path = os.path.join(PDF_DIR, filename)
     if not os.path.exists(file_path):
         raise HTTPException(status_code=404, detail="PDF file not found")
-    return FileResponse(file_path, media_type="application/pdf", filename=filename)
+    return FileResponse(file_path, media_type="application/pdf", filename=filename)