Update app.py

app.py

@@ -50,37 +50,57 @@ logger.debug(f"Compiled in {compile_time}s")
 
 @app.post("/transcribe_audio")
 async def transcribe_chunked_audio(audio_file: UploadFile, task: str = "transcribe", return_timestamps: bool = False):
-    logger.debug("Loading audio file...")
+    logger.debug("Starting transcribe_chunked_audio function")
+    logger.debug(f"Received parameters - task: {task}, return_timestamps: {return_timestamps}")
+    
+    logger.debug("Checking for audio file...")
     if not audio_file:
         logger.warning("No audio file")
         raise HTTPException(status_code=400, detail="No audio file submitted!")
-    file_size_mb = os.stat(audio_file.filename).st_size / (1024 * 1024)
+    
+    logger.debug(f"Audio file received: {audio_file.filename}")
+    
+    try:
+        file_size_mb = os.stat(audio_file.filename).st_size / (1024 * 1024)
+        logger.debug(f"File size: {file_size_mb:.2f}MB")
+    except Exception as e:
+        logger.error(f"Error getting file size: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail="Error checking file size")
+
     if file_size_mb > FILE_LIMIT_MB:
-        logger.warning("Max file size exceeded")
+        logger.warning(f"Max file size exceeded: {file_size_mb:.2f}MB > {FILE_LIMIT_MB}MB")
         raise HTTPException(status_code=400, detail=f"File size exceeds file size limit. Got file of size {file_size_mb:.2f}MB for a limit of {FILE_LIMIT_MB}MB.")
 
     try:
         logger.debug(f"Opening audio file: {audio_file.filename}")
         with open(audio_file.filename, "rb") as f:
             inputs = f.read()
+        logger.debug("Audio file read successfully")
     except Exception as e:
-        logger.error("Error reading audio file:", exc_info=True)
-        raise HTTPException(status_code=500, detail="Error reading audio file")
+        logger.error(f"Error reading audio file: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Error reading audio file: {str(e)}")
 
-    logger.debug("Performing ffmpeg read on audio file")
-    inputs = ffmpeg_read(inputs, pipeline.feature_extractor.sampling_rate)
-    inputs = {"array": inputs, "sampling_rate": pipeline.feature_extractor.sampling_rate}
-    logger.debug("Done loading audio file")
+    try:
+        logger.debug("Performing ffmpeg read on audio file")
+        inputs = ffmpeg_read(inputs, pipeline.feature_extractor.sampling_rate)
+        inputs = {"array": inputs, "sampling_rate": pipeline.feature_extractor.sampling_rate}
+        logger.debug("ffmpeg read completed successfully")
+    except Exception as e:
+        logger.error(f"Error in ffmpeg read: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Error processing audio file: {str(e)}")
 
+    logger.debug("Calling tqdm_generate to transcribe audio")
     try:
-        logger.debug("Calling tqdm_generate to transcribe audio")
         text, runtime = tqdm_generate(inputs, task=task, return_timestamps=return_timestamps)
+        logger.debug(f"Transcription completed. Runtime: {runtime:.2f}s")
     except Exception as e:
-        logger.error("Error transcribing audio:", exc_info=True)
-        raise HTTPException(status_code=500, detail="Error transcribing audio")
+        logger.error(f"Error in tqdm_generate: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Error transcribing audio: {str(e)}")
 
+    logger.debug("Transcribe_chunked_audio function completed successfully")
     return {"text": text, "runtime": runtime}
 
+
 @app.post("/transcribe_youtube")
 async def transcribe_youtube(yt_url: str = Form(...), task: str = "transcribe", return_timestamps: bool = False):
     logger.debug("Loading YouTube file...")
@@ -121,29 +141,49 @@ async def transcribe_youtube(yt_url: str = Form(...), task: str = "transcribe",
     return {"html_embed": html_embed_str, "text": text, "runtime": runtime}
 
 def tqdm_generate(inputs: dict, task: str, return_timestamps: bool):
+    logger.debug(f"Starting tqdm_generate - task: {task}, return_timestamps: {return_timestamps}")
+    
     inputs_len = inputs["array"].shape[0]
+    logger.debug(f"Input array length: {inputs_len}")
+    
     all_chunk_start_idx = np.arange(0, inputs_len, step)
     num_samples = len(all_chunk_start_idx)
     num_batches = math.ceil(num_samples / BATCH_SIZE)
+    logger.debug(f"Number of samples: {num_samples}, Number of batches: {num_batches}")
 
     logger.debug("Preprocessing audio for inference")
-    dataloader = pipeline.preprocess_batch(inputs, chunk_length_s=CHUNK_LENGTH_S, batch_size=BATCH_SIZE)
+    try:
+        dataloader = pipeline.preprocess_batch(inputs, chunk_length_s=CHUNK_LENGTH_S, batch_size=BATCH_SIZE)
+        logger.debug("Preprocessing completed successfully")
+    except Exception as e:
+        logger.error(f"Error in preprocessing: {str(e)}", exc_info=True)
+        raise
+
     model_outputs = []
     start_time = time.time()
-    logger.debug("Transcribing...")
-    # iterate over our chunked audio samples - always predict timestamps to reduce hallucinations
-    for batch in dataloader:
-        logger.debug(f"Processing batch of {len(batch)} samples")
-        model_outputs.append(pipeline.forward(batch, batch_size=BATCH_SIZE, task=task, return_timestamps=True))
+    logger.debug("Starting transcription...")
+    
+    try:
+        for i, batch in enumerate(dataloader):
+            logger.debug(f"Processing batch {i+1}/{num_batches} with {len(batch)} samples")
+            batch_output = pipeline.forward(batch, batch_size=BATCH_SIZE, task=task, return_timestamps=True)
+            model_outputs.append(batch_output)
+            logger.debug(f"Batch {i+1} processed successfully")
+    except Exception as e:
+        logger.error(f"Error during batch processing: {str(e)}", exc_info=True)
+        raise
+
     runtime = time.time() - start_time
-    logger.debug("Done transcription")
+    logger.debug(f"Transcription completed in {runtime:.2f}s")
 
     logger.debug("Post-processing transcription results")
     try:
         post_processed = pipeline.postprocess(model_outputs, return_timestamps=True)
+        logger.debug("Post-processing completed successfully")
     except Exception as e:
-        logger.error("Error post-processing transcription:", exc_info=True)
-        raise HTTPException(status_code=500, detail="Error post-processing transcription")
+        logger.error(f"Error in post-processing: {str(e)}", exc_info=True)
+        raise
+
     text = post_processed["text"]
     if return_timestamps:
         timestamps = post_processed.get("chunks")
@@ -152,7 +192,8 @@ def tqdm_generate(inputs: dict, task: str, return_timestamps: bool):
             for chunk in timestamps
         ]
         text = "\n".join(str(feature) for feature in timestamps)
-    logger.debug("Done post-processing")
+    
+    logger.debug("tqdm_generate function completed successfully")
     return text, runtime
 
 def _return_yt_html_embed(yt_url):