dsflasd

app.py

@@ -1,7 +1,483 @@
-from fastapi import FastAPI
+from fastapi import FastAPI, UploadFile, HTTPException
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+import sys
+import os
+import shutil
+import uuid
+
+# Ensure sibling module fluency is discoverable
+#sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__))))
+
+from fluency.fluency_api import main as analyze_fluency_main
+from tone_modulation.tone_api import main as analyze_tone_main
+from vcs.vcs_api import main as analyze_vcs_main
+from vers.vers_api import main as analyze_vers_main
+from voice_confidence_score.voice_confidence_api import main as analyze_voice_confidence_main
+from vps.vps_api import main as analyze_vps_main
+from ves.ves import calc_voice_engagement_score
+from transcribe import transcribe_audio
+from filler_count.filler_score import analyze_fillers
+
+import logging
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,  # Or DEBUG for more verbose logs
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    handlers=[
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+
+logger = logging.getLogger(__name__)
+
+
+
+
+
+
+
 
 app = FastAPI()
 
-@app.get("/hello")
-def hello():
-    return {"message": "Hello, World!"}
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # In production, replace "*" with allowed frontend domains
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/")
+def home():
+    return {"status": "Running"}
+
+@app.get("/health")
+def health_check():
+    return {"status": "ok"}
+
+
+# this will just rturen that audio file is being ready for analysis
+@app.post("/audio_status/")
+async def audio_status(file: UploadFile):
+    """
+    Endpoint to check the status of an uploaded audio file (.wav or .mp3).
+    """
+    if not file.filename.endswith(('.wav', '.mp3')):
+        raise HTTPException(status_code=400, detail="Invalid file type. Only .wav and .mp3 files are supported.")
+    
+    # Generate a safe temporary file path
+    temp_filename = f"temp_{uuid.uuid4()}{os.path.splitext(file.filename)[1]}"
+    temp_dir = "temp_uploads"
+    temp_filepath = os.path.join(temp_dir, temp_filename)
+    os.makedirs(temp_dir, exist_ok=True)
+
+    try:
+        # Save uploaded file
+        with open(temp_filepath, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+
+        return JSONResponse(content={"status": "File is ready for analysis"})
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"File status check failed: {str(e)}")
+
+    finally:
+        # Clean up temporary file
+        if os.path.exists(temp_filepath):
+            os.remove(temp_filepath)
+
+
+
+@app.post("/analyze_fluency/")
+async def analyze_fluency(file: UploadFile):
+    # idk if we can use pydantic model here If we need I can add later
+    if not file.filename.endswith(('.wav', '.mp3')):
+        raise HTTPException(status_code=400, detail="Invalid file type. Only .wav and .mp3 files are supported.")
+    
+    # Generate a safe temporary file path for temporary storage of the uploaded file this will be deleted after processing
+    temp_filename = f"temp_{uuid.uuid4()}{os.path.splitext(file.filename)[1]}"
+    temp_dir = "temp_uploads"
+    temp_filepath = os.path.join(temp_dir, temp_filename)
+    os.makedirs(temp_dir, exist_ok=True)
+
+    try:
+        # Save uploaded file
+        with open(temp_filepath, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+
+
+        result = analyze_fluency_main(temp_filepath, model_size="base")
+
+        return JSONResponse(content=result)
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Fluency analysis failed: {str(e)}")
+
+    finally:
+        # Clean up temporary file
+        if os.path.exists(temp_filepath):
+            os.remove(temp_filepath)
+            
+# @app.post('/analyze_tone/')
+# async def analyze_tone(file: UploadFile):
+#     """
+#     Endpoint to analyze tone of an uploaded audio file (.wav or .mp3).
+#     """
+#     if not file.filename.endswith(('.wav', '.mp3')):
+#         raise HTTPException(status_code=400, detail="Invalid file type. Only .wav and .mp3 files are supported.")
+    
+#     # Generate a safe temporary file path
+#     temp_filename = f"temp_{uuid.uuid4()}{os.path.splitext(file.filename)[1]}"
+#     temp_dir = "temp_uploads"
+#     temp_filepath = os.path.join(temp_dir, temp_filename)
+#     os.makedirs(temp_dir, exist_ok=True)
+
+#     try:
+#         # Save uploaded file
+#         with open(temp_filepath, "wb") as buffer:
+#             shutil.copyfileobj(file.file, buffer)
+
+#         # Analyze tone using your custom function
+#         result = analyze_tone_main(temp_filepath)
+
+#         return JSONResponse(content=result)
+
+#     except Exception as e:
+#         raise HTTPException(status_code=500, detail=f"Tone analysis failed: {str(e)}")
+
+#     finally:
+#         # Clean up temporary file
+#         if os.path.exists(temp_filepath):
+#             os.remove(temp_filepath)
+
+@app.post('/analyze_tone/')
+async def analyze_tone(file: UploadFile):
+    logger.info(f"Received file for tone analysis: {file.filename}")
+
+    if not file.filename.endswith(('.wav', '.mp3')):
+        logger.warning("Invalid file type received")
+        raise HTTPException(status_code=400, detail="Invalid file type. Only .wav and .mp3 files are supported.")
+    
+    temp_filename = f"temp_{uuid.uuid4()}{os.path.splitext(file.filename)[1]}"
+    temp_dir = "temp_uploads"
+    temp_filepath = os.path.join(temp_dir, temp_filename)
+    os.makedirs(temp_dir, exist_ok=True)
+
+    try:
+        logger.info(f"Saving uploaded file to {temp_filepath}")
+        with open(temp_filepath, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+
+        logger.info("Calling analyze_tone_main...")
+        result = analyze_tone_main(temp_filepath)
+        logger.info("Tone analysis completed successfully")
+
+        return JSONResponse(content=result)
+
+    except Exception as e:
+        logger.error(f"Tone analysis failed: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Tone analysis failed: {str(e)}")
+
+    finally:
+        if os.path.exists(temp_filepath):
+            logger.info(f"Cleaning up temporary file: {temp_filepath}")
+            os.remove(temp_filepath)
+
+
+
+
+@app.post('/analyze_vcs/')
+async def analyze_vcs(file: UploadFile):
+    """
+    Endpoint to analyze voice clarity of an uploaded audio file (.wav or .mp3).
+    """
+    if not file.filename.endswith(('.wav', '.mp3')):
+        raise HTTPException(status_code=400, detail="Invalid file type. Only .wav and .mp3 files are supported.")
+    
+    # Generate a safe temporary file path
+    temp_filename = f"temp_{uuid.uuid4()}{os.path.splitext(file.filename)[1]}"
+    temp_dir = "temp_uploads"
+    temp_filepath = os.path.join(temp_dir, temp_filename)
+    os.makedirs(temp_dir, exist_ok=True)
+
+    try:
+        # Save uploaded file
+        with open(temp_filepath, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+
+        # Analyze voice clarity using your custom function
+        result = analyze_vcs_main(temp_filepath)
+
+        return JSONResponse(content=result)
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Voice clarity analysis failed: {str(e)}")
+
+    finally:
+        # Clean up temporary file
+        if os.path.exists(temp_filepath):
+            os.remove(temp_filepath)
+
+@app.post('/analyze_vers/')
+async def analyze_vers(file: UploadFile):
+    """
+    Endpoint to analyze VERS of an uploaded audio file (.wav or .mp3).
+    """
+    if not file.filename.endswith(('.wav', '.mp3')):
+        raise HTTPException(status_code=400, detail="Invalid file type. Only .wav and .mp3 files are supported.")
+    
+    # Generate a safe temporary file path
+    temp_filename = f"temp_{uuid.uuid4()}{os.path.splitext(file.filename)[1]}"
+    temp_dir = "temp_uploads"
+    temp_filepath = os.path.join(temp_dir, temp_filename)
+    os.makedirs(temp_dir, exist_ok=True)
+
+    try:
+        # Save uploaded file
+        with open(temp_filepath, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+
+        # Analyze VERS using your custom function
+        result = analyze_vers_main(temp_filepath)
+
+        return JSONResponse(content=result)
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"VERS analysis failed: {str(e)}")
+
+    finally:
+        # Clean up temporary file
+        if os.path.exists(temp_filepath):
+            os.remove(temp_filepath)
+            
+@app.post('/voice_confidence/')
+async def analyze_voice_confidence(file: UploadFile):
+    """
+    Endpoint to analyze voice confidence of an uploaded audio file (.wav or .mp3).
+    """
+    if not file.filename.endswith(('.wav', '.mp3')):
+        raise HTTPException(status_code=400, detail="Invalid file type. Only .wav and .mp3 files are supported.")
+    
+    # Generate a safe temporary file path
+    temp_filename = f"temp_{uuid.uuid4()}{os.path.splitext(file.filename)[1]}"
+    temp_dir = "temp_uploads"
+    temp_filepath = os.path.join(temp_dir, temp_filename)
+    os.makedirs(temp_dir, exist_ok=True)
+
+    try:
+        # Save uploaded file
+        with open(temp_filepath, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+
+        # Analyze voice confidence using your custom function
+        result = analyze_voice_confidence_main(temp_filepath)
+
+        return JSONResponse(content=result)
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Voice confidence analysis failed: {str(e)}")
+
+    finally:
+        # Clean up temporary file
+        if os.path.exists(temp_filepath):
+            os.remove(temp_filepath)
+
+@app.post('/analyze_vps/')
+async def analyze_vps(file: UploadFile):
+    """
+    Endpoint to analyze voice pacing score of an uploaded audio file (.wav or .mp3).
+    """
+    if not file.filename.endswith(('.wav', '.mp3')):
+        raise HTTPException(status_code=400, detail="Invalid file type. Only .wav and .mp3 files are supported.")
+    
+    # Generate a safe temporary file path
+    temp_filename = f"temp_{uuid.uuid4()}{os.path.splitext(file.filename)[1]}"
+    temp_dir = "temp_uploads"
+    temp_filepath = os.path.join(temp_dir, temp_filename)
+    os.makedirs(temp_dir, exist_ok=True)
+
+    try:
+        # Save uploaded file
+        with open(temp_filepath, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+
+        # Analyze voice pacing score using your custom function
+        result = analyze_vps_main(temp_filepath)
+
+        return JSONResponse(content=result)
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Voice pacing score analysis failed: {str(e)}")
+
+    finally:
+        # Clean up temporary file
+        if os.path.exists(temp_filepath):
+            os.remove(temp_filepath)
+
+@app.post('/voice_engagement_score/')
+async def analyze_voice_engagement_score(file: UploadFile):
+    """
+    Endpoint to analyze voice engagement score of an uploaded audio file (.wav or .mp3).
+    """
+    if not file.filename.endswith(('.wav', '.mp3')):
+        raise HTTPException(status_code=400, detail="Invalid file type. Only .wav and .mp3 files are supported.")
+    
+    # Generate a safe temporary file path
+    temp_filename = f"temp_{uuid.uuid4()}{os.path.splitext(file.filename)[1]}"
+    temp_dir = "temp_uploads"
+    temp_filepath = os.path.join(temp_dir, temp_filename)
+    os.makedirs(temp_dir, exist_ok=True)
+
+    try:
+        # Save uploaded file
+        with open(temp_filepath, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+
+        # Analyze voice engagement score using your custom function
+        result = calc_voice_engagement_score(temp_filepath)
+
+        return JSONResponse(content=result)
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Voice engagement score analysis failed: {str(e)}")
+
+    finally:
+        # Clean up temporary file
+        if os.path.exists(temp_filepath):
+            os.remove(temp_filepath)
+
+@app.post('/analyze_fillers/')
+async def analyze_fillers_count(file: UploadFile):
+    """
+    Endpoint to analyze filler words in an uploaded audio file (.wav or .mp3).
+    """
+    if not file.filename.endswith(('.wav', '.mp3','.mp4')):
+        raise HTTPException(status_code=400, detail="Invalid file type. Only .wav and .mp3 files are supported.")
+    
+    # Generate a safe temporary file path
+    temp_filename = f"temp_{uuid.uuid4()}{os.path.splitext(file.filename)[1]}"
+    temp_dir = "temp_uploads"
+    temp_filepath = os.path.join(temp_dir, temp_filename)
+    os.makedirs(temp_dir, exist_ok=True)
+
+    try:
+        # Save uploaded file
+        with open(temp_filepath, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+
+        # Call the analysis function with the file path
+        result = analyze_fillers(temp_filepath)  # Pass the file path, not the UploadFile object
+
+        return JSONResponse(content=result)
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Filler analysis failed: {str(e)}")
+
+    finally:
+        # Clean up temporary file
+        if os.path.exists(temp_filepath):
+            os.remove(temp_filepath)
+
+
+import time 
+
+
+
+@app.post('/transcribe/')
+async def transcribe(file: UploadFile):
+    """
+    Endpoint to transcribe an uploaded audio file (.wav or .mp3).
+    """
+    #calculate time to transcribe
+    start_time = time.time()
+    if not file.filename.endswith(('.wav', '.mp3')):
+        raise HTTPException(status_code=400, detail="Invalid file type. Only .wav and .mp3 files are supported.")
+    
+    # Generate a safe temporary file path
+    temp_filename = f"temp_{uuid.uuid4()}{os.path.splitext(file.filename)[1]}"
+    temp_dir = "temp_uploads"
+    temp_filepath = os.path.join(temp_dir, temp_filename)
+    os.makedirs(temp_dir, exist_ok=True)
+
+    try:
+        # Save uploaded file
+        with open(temp_filepath, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+
+        # Transcribe using your custom function
+        result = transcribe_audio(temp_filepath)
+        end_time = time.time()
+        transcription_time = end_time - start_time
+        response = {
+            "transcription": result,
+            "transcription_time": transcription_time
+        }
+    
+        return JSONResponse(content=response)
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Transcription failed: {str(e)}")
+    
+    finally:
+        # Clean up temporary file
+        if os.path.exists(temp_filepath):
+            os.remove(temp_filepath)
+
+
+
+@app.post('/analyze_all/')
+async def analyze_all(file: UploadFile):
+    """
+    Endpoint to analyze all aspects of an uploaded audio file (.wav or .mp3).
+    """
+    if not file.filename.endswith(('.wav', '.mp3')):
+        raise HTTPException(status_code=400, detail="Invalid file type. Only .wav and .mp3 files are supported.")
+    
+    # Generate a safe temporary file path
+    temp_filename = f"temp_{uuid.uuid4()}{os.path.splitext(file.filename)[1]}"
+    temp_dir = "temp_uploads"
+    temp_filepath = os.path.join(temp_dir, temp_filename)
+    os.makedirs(temp_dir, exist_ok=True)
+
+    try:
+        # Save uploaded file
+        with open(temp_filepath, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+
+        # Analyze all aspects using your custom functions
+        fluency_result = analyze_fluency_main(temp_filepath, model_size="base")
+        tone_result = analyze_tone_main(temp_filepath)
+        vcs_result = analyze_vcs_main(temp_filepath)
+        vers_result = analyze_vers_main(temp_filepath)
+        voice_confidence_result = analyze_voice_confidence_main(temp_filepath)
+        vps_result = analyze_vps_main(temp_filepath)
+        ves_result = calc_voice_engagement_score(temp_filepath)
+        transcript = transcribe_audio(temp_filepath)
+
+        # Combine results into a single response
+        combined_result = {
+            "fluency": fluency_result,
+            "tone": tone_result,
+            "vcs": vcs_result,
+            "vers": vers_result,
+            "voice_confidence": voice_confidence_result,
+            "vps": vps_result,
+            "ves": ves_result,
+            "transcript": transcript
+        }
+
+        return JSONResponse(content=combined_result)
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Analysis failed: {str(e)}")
+
+    finally:
+        # Clean up temporary file
+        if os.path.exists(temp_filepath):
+            os.remove(temp_filepath)
+            
+# if __name__ == "__main__":
+#     import uvicorn
+#     uvicorn.run("main:app", host="0.0.0.0", port=int(os.environ.get("PORT", 10000)), reload=False)