Update app.py

app.py

@@ -11,6 +11,8 @@ import librosa
 from pathlib import Path
 import magic  # For MIME type detection
 from pydub import AudioSegment
+import traceback
+from logging.handlers import RotatingFileHandler
 
 # Import functions from other modules
 from asr import transcribe, ASR_LANGUAGES
@@ -22,6 +24,13 @@ from asr import ASR_SAMPLING_RATE
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+# Add a file handler
+file_handler = RotatingFileHandler('app.log', maxBytes=10000000, backupCount=5)
+file_handler.setLevel(logging.INFO)
+formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+file_handler.setFormatter(formatter)
+logger.addHandler(file_handler)
+
 app = FastAPI(title="MMS: Scaling Speech Technology to 1000+ languages")
 
 # Define request models
@@ -71,41 +80,72 @@ async def transcribe_audio(request: AudioRequest):
         result = transcribe(audio_array, request.language)
         return JSONResponse(content={"transcription": result})
     except Exception as e:
-        logger.error(f"Error in transcribe_audio: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
+        logger.error(f"Error in transcribe_audio: {str(e)}", exc_info=True)
+        error_details = {
+            "error": str(e),
+            "traceback": traceback.format_exc()
+        }
+        return JSONResponse(
+            status_code=500,
+            content={"message": "An error occurred during transcription", "details": error_details}
+        )
 
 @app.post("/synthesize")
 async def synthesize_speech(request: TTSRequest):
     try:
-        logger.info(f"Synthesizing speech for text: {request.text}, language: {request.language}, speed: {request.speed}")
+        logger.info(f"Synthesize request received: text='{request.text}', language='{request.language}', speed={request.speed}")
+        
+        logger.info("Calling synthesize function")
         result, filtered_text = synthesize(request.text, request.language, request.speed)
-        logger.info(f"Synthesis complete. Filtered text: {filtered_text}")
+        logger.info(f"Synthesize function completed. Filtered text: '{filtered_text}'")
+        
+        if result is None:
+            logger.error("Synthesize function returned None")
+            raise ValueError("Synthesis failed to produce audio")
         
         sample_rate, audio = result
-        logger.info(f"Sample rate: {sample_rate}, Audio shape: {audio.shape}, Audio dtype: {audio.dtype}")
-
-        # Ensure audio is a numpy array with the correct dtype
+        logger.info(f"Synthesis result: sample_rate={sample_rate}, audio_shape={audio.shape}, audio_dtype={audio.dtype}")
+        
+        logger.info("Converting audio to numpy array")
         audio = np.array(audio, dtype=np.float32)
+        logger.info(f"Converted audio shape: {audio.shape}, dtype: {audio.dtype}")
         
-        # Normalize audio to [-1, 1] range
-        audio = audio / np.max(np.abs(audio))
+        logger.info("Normalizing audio")
+        max_value = np.max(np.abs(audio))
+        if max_value == 0:
+            logger.warning("Audio array is all zeros")
+        audio = audio / max(max_value, 1e-8)  # Avoid division by zero
+        logger.info(f"Normalized audio range: [{audio.min()}, {audio.max()}]")
         
-        # Convert to int16 for WAV file
+        logger.info("Converting to int16")
         audio = (audio * 32767).astype(np.int16)
+        logger.info(f"Int16 audio shape: {audio.shape}, dtype: {audio.dtype}")
         
-        # Convert numpy array to bytes
+        logger.info("Writing audio to buffer")
         buffer = io.BytesIO()
         sf.write(buffer, audio, sample_rate, format='wav')
         buffer.seek(0)
+        logger.info(f"Buffer size: {buffer.getbuffer().nbytes} bytes")
         
-        return FileResponse(
+        logger.info("Preparing FileResponse")
+        response = FileResponse(
             buffer,
             media_type="audio/wav",
             headers={"Content-Disposition": "attachment; filename=synthesized_audio.wav"}
         )
+        logger.info("FileResponse prepared successfully")
+        
+        return response
     except Exception as e:
-        logger.error(f"Error in synthesize_speech: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
+        logger.error(f"Error in synthesize_speech: {str(e)}", exc_info=True)
+        error_details = {
+            "error": str(e),
+            "traceback": traceback.format_exc()
+        }
+        return JSONResponse(
+            status_code=500,
+            content={"message": "An error occurred during speech synthesis", "details": error_details}
+        )
 
 @app.post("/identify")
 async def identify_language(request: AudioRequest):
@@ -115,21 +155,42 @@ async def identify_language(request: AudioRequest):
         result = identify(audio_array)
         return JSONResponse(content={"language_identification": result})
     except Exception as e:
-        logger.error(f"Error in identify_language: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
+        logger.error(f"Error in identify_language: {str(e)}", exc_info=True)
+        error_details = {
+            "error": str(e),
+            "traceback": traceback.format_exc()
+        }
+        return JSONResponse(
+            status_code=500,
+            content={"message": "An error occurred during language identification", "details": error_details}
+        )
 
 @app.get("/asr_languages")
 async def get_asr_languages():
     try:
         return JSONResponse(content=ASR_LANGUAGES)
     except Exception as e:
-        logger.error(f"Error in get_asr_languages: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
+        logger.error(f"Error in get_asr_languages: {str(e)}", exc_info=True)
+        error_details = {
+            "error": str(e),
+            "traceback": traceback.format_exc()
+        }
+        return JSONResponse(
+            status_code=500,
+            content={"message": "An error occurred while fetching ASR languages", "details": error_details}
+        )
 
 @app.get("/tts_languages")
 async def get_tts_languages():
     try:
         return JSONResponse(content=TTS_LANGUAGES)
     except Exception as e:
-        logger.error(f"Error in get_tts_languages: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
+        logger.error(f"Error in get_tts_languages: {str(e)}", exc_info=True)
+        error_details = {
+            "error": str(e),
+            "traceback": traceback.format_exc()
+        }
+        return JSONResponse(
+            status_code=500,
+            content={"message": "An error occurred while fetching TTS languages", "details": error_details}
+        )