Update app.py

app.py

@@ -2,140 +2,164 @@ import os
 import uuid
 import subprocess
 import requests
-import base64
-from fastapi import FastAPI, UploadFile, File, Form, HTTPException, Request
-from fastapi.responses import HTMLResponse, JSONResponse
-from fastapi.middleware.cors import CORSMiddleware
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse, HTMLResponse
 
 app = FastAPI()
 
-# Allow CORS for testing
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
 # Base directory to store task files
 BASE_DIR = "tasks"
 os.makedirs(BASE_DIR, exist_ok=True)
 
+def add_status(log_list, message):
+    log_list.append(message)
+    print(message)  # Optionally log to console
+
 @app.post("/process")
-async def process_audio(
-    request: Request,
-    file: UploadFile = File(None),
-    url: str = Form(None)
-):
-    if not file and not url:
-        raise HTTPException(status_code=400, detail="Provide either a file or a URL.")
+def process_audio(payload: dict):
+    status_log = []
+    # Check for required URL parameter in the payload
+    if "url" not in payload:
+        raise HTTPException(status_code=400, detail="Missing 'url' in payload")
+    
+    audio_url = payload["url"]
+    add_status(status_log, "Received URL from payload.")
 
-    # Generate unique task ID and create folder for this task
+    # Create a unique task folder
     task_id = str(uuid.uuid4())
     task_dir = os.path.join(BASE_DIR, task_id)
     os.makedirs(task_dir, exist_ok=True)
+    add_status(status_log, f"Created task directory: {task_dir}")
+
+    # Check FFmpeg version
+    try:
+        ffmpeg_ver = subprocess.run(
+            ["ffmpeg", "-version"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        first_line = ffmpeg_ver.stdout.splitlines()[0]
+        add_status(status_log, f"FFmpeg version: {first_line}")
+    except Exception as e:
+        add_status(status_log, f"Failed to get FFmpeg version: {e}")
+        return JSONResponse(status_code=500, content={"status": status_log})
+
+    # Check Spleeter version
+    try:
+        spleeter_ver = subprocess.run(
+            ["spleeter", "--version"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        add_status(status_log, f"Spleeter version: {spleeter_ver.stdout.strip()}")
+    except Exception as e:
+        add_status(status_log, f"Failed to get Spleeter version: {e}")
+        return JSONResponse(status_code=500, content={"status": status_log})
+
+    # Download the audio file from the URL
+    try:
+        r = requests.get(audio_url)
+        r.raise_for_status()
+        add_status(status_log, "Successfully downloaded audio file.")
+    except Exception as e:
+        add_status(status_log, f"Error downloading file: {e}")
+        return JSONResponse(status_code=400, content={"status": status_log})
 
-    # Download or read the file
-    if file:
-        filename = file.filename
-        input_path = os.path.join(task_dir, filename)
-        with open(input_path, "wb") as f:
-            content = await file.read()
-            f.write(content)
-    else:
-        # Download file from provided URL
-        resp = requests.get(url)
-        if resp.status_code != 200:
-            raise HTTPException(status_code=400, detail="Failed to download file from URL.")
-        ext = os.path.splitext(url)[1] or ".mp3"
-        filename = f"input{ext}"
-        input_path = os.path.join(task_dir, filename)
-        with open(input_path, "wb") as f:
-            f.write(resp.content)
+    # Determine file extension (default to .mp3 if not found)
+    ext = os.path.splitext(audio_url)[1] or ".mp3"
+    input_filename = f"input{ext}"
+    input_filepath = os.path.join(task_dir, input_filename)
 
-    # Run Spleeter to separate into 2 stems (vocals and accompaniment)
-    # Spleeter will create a subfolder named after the input file (without extension)
-    cmd = [
+    # Save the downloaded file
+    try:
+        with open(input_filepath, "wb") as f:
+            f.write(r.content)
+        add_status(status_log, f"Saved audio file to: {input_filepath}")
+    except Exception as e:
+        add_status(status_log, f"Error saving file: {e}")
+        return JSONResponse(status_code=500, content={"status": status_log})
+
+    # Verify that the file exists
+    if not os.path.exists(input_filepath):
+        add_status(status_log, "Error: Input file does not exist after download.")
+        return JSONResponse(status_code=500, content={"status": status_log})
+
+    # Run Spleeter to separate the file using the 2-stems model (vocals and accompaniment)
+    base_name = os.path.splitext(input_filename)[0]
+    spleeter_cmd = [
         "spleeter", "separate",
-        "-i", input_path,
+        "-i", input_filepath,
         "-p", "spleeter:2stems",
         "-o", task_dir
     ]
+    add_status(status_log, "Running Spleeter command: " + " ".join(spleeter_cmd))
     try:
-        subprocess.run(cmd, check=True)
+        result = subprocess.run(
+            spleeter_cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        add_status(status_log, "Spleeter command output: " + result.stdout)
     except subprocess.CalledProcessError as e:
-        raise HTTPException(status_code=500, detail=f"Spleeter processing failed: {e}")
-
-    # Determine output folder name and expected files
-    base_name = os.path.splitext(filename)[0]
-    output_dir = os.path.join(task_dir, base_name)
-    vocals_path = os.path.join(output_dir, "vocals.wav")
-    accomp_path = os.path.join(output_dir, "accompaniment.wav")
+        add_status(status_log, "Spleeter processing failed: " + e.stderr)
+        return JSONResponse(status_code=500, content={"status": status_log})
 
-    if not (os.path.exists(vocals_path) and os.path.exists(accomp_path)):
-        raise HTTPException(status_code=500, detail="Output files not found after processing.")
-
-    # Read output files and encode in base64
-    with open(vocals_path, "rb") as f:
-        vocals_data = f.read()
-    with open(accomp_path, "rb") as f:
-        accomp_data = f.read()
-
-    vocals_b64 = base64.b64encode(vocals_data).decode("utf-8")
-    accomp_b64 = base64.b64encode(accomp_data).decode("utf-8")
+    # Define expected output files
+    output_folder = os.path.join(task_dir, base_name)
+    vocals_file = os.path.join(output_folder, "vocals.wav")
+    accompaniment_file = os.path.join(output_folder, "accompaniment.wav")
+    if not (os.path.exists(vocals_file) and os.path.exists(accompaniment_file)):
+        add_status(status_log, "Error: Output files not found after processing.")
+        return JSONResponse(status_code=500, content={"status": status_log})
+    
+    add_status(status_log, "Spleeter processing completed successfully.")
 
+    # Return the task ID and status log to the frontend
     return JSONResponse(content={
         "task_id": task_id,
-        "vocals": vocals_b64,
-        "accompaniment": accomp_b64
+        "status": status_log
     })
 
 @app.get("/", response_class=HTMLResponse)
 def index():
+    # Simple HTML page to test the API and display status logs.
     html_content = """
     <!DOCTYPE html>
     <html>
     <head>
-        <title>Spleeter API Test</title>
+        <title>Spleeter Processing Test</title>
     </head>
     <body>
-        <h1>Spleeter API Test</h1>
-        <form id="spleeterForm" enctype="multipart/form-data">
-            <div>
-                <label>Upload File:</label>
-                <input type="file" name="file">
-            </div>
-            <div>
-                <label>Or Enter URL:</label>
-                <input type="text" name="url" size="50">
-            </div>
+        <h1>Spleeter Processing Test</h1>
+        <form id="spleeterForm">
+            Audio URL: <input type="text" name="url" size="50"/><br/><br/>
             <button type="submit">Process Audio</button>
         </form>
-        <div id="result"></div>
+        <div id="result" style="margin-top:20px;"></div>
         <script>
             const form = document.getElementById('spleeterForm');
             form.onsubmit = async (e) => {
                 e.preventDefault();
                 const formData = new FormData(form);
+                const url = formData.get('url');
                 const response = await fetch('/process', {
                     method: 'POST',
-                    body: formData
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ url })
                 });
                 const data = await response.json();
-                if (response.ok) {
-                    const vocalsSrc = "data:audio/wav;base64," + data.vocals;
-                    const accompSrc = "data:audio/wav;base64," + data.accompaniment;
-                    
-                    document.getElementById('result').innerHTML = `
-                        <h3>Vocals</h3>
-                        <audio controls src="${vocalsSrc}"></audio>
-                        <h3>Accompaniment</h3>
-                        <audio controls src="${accompSrc}"></audio>
-                    `;
-                } else {
-                    document.getElementById('result').innerHTML = `<p>Error: ${data.detail}</p>`;
+                let resultHTML = "<h3>Status Log:</h3><ul>";
+                for (const log of data.status) {
+                    resultHTML += "<li>" + log + "</li>";
+                }
+                resultHTML += "</ul>";
+                if(data.task_id) {
+                    resultHTML += `<p>Task ID: ${data.task_id}</p>`;
                 }
+                document.getElementById('result').innerHTML = resultHTML;
             };
         </script>
     </body>