Update app.py

app.py

@@ -60,7 +60,8 @@ def process_video(video_file, language="hindi", progress=gr.Progress()):
         print(f"Extracting audio from: {video_file}")
         video = VideoFileClip(video_file)
         if not video.audio:
-            shutil.rmtree(output_dir)
+            shutil.rmtree(temp_dir, ignore_errors=True)
+            shutil.rmtree(output_dir, ignore_errors=True)
             return None, None, "Video has no audio track"
         
         video.audio.write_audiofile(
@@ -78,7 +79,7 @@ def process_video(video_file, language="hindi", progress=gr.Progress()):
         progress(0.4, desc="Transcribing with Whisper Turbo...")
         print(f"Starting transcription (language: {language})...")
         
-        result = pipe(
+        transcription_result = pipe(
             audio_path,
             return_timestamps=True,
             generate_kwargs={
@@ -87,67 +88,48 @@ def process_video(video_file, language="hindi", progress=gr.Progress()):
             }
         )
         
-        print(f"Transcription result keys: {result.keys()}")
+        print(f"Transcription result keys: {transcription_result.keys()}")
         
         # Verify we have chunks
-        if not result.get('chunks') or len(result['chunks']) == 0:
-            error_msg = f"Transcription returned no segments. Full result: {result}"
+        if not transcription_result.get('chunks') or len(transcription_result['chunks']) == 0:
+            error_msg = f"Transcription returned no segments. Full result: {transcription_result}"
             print(error_msg)
-            shutil.rmtree(output_dir)
+            shutil.rmtree(temp_dir, ignore_errors=True)
+            shutil.rmtree(output_dir, ignore_errors=True)
             return None, None, error_msg
         
-        print(f"Transcription complete: {len(result['chunks'])} segments")
+        print(f"Transcription complete: {len(transcription_result['chunks'])} segments")
         
         # Create SRT in output directory (persistent)
         progress(0.6, desc="Creating SRT...")
         srt_path = os.path.join(output_dir, "subtitles.srt")
         
         print(f"Creating SRT at: {srt_path}")
-        print(f"Output directory exists: {os.path.exists(output_dir)}")
-        print(f"Output directory contents before SRT: {os.listdir(output_dir)}")
-        
-        try:
-            with open(srt_path, 'w', encoding='utf-8-sig') as f:
-                for i, chunk in enumerate(result['chunks'], 1):
-                    start, end = chunk['timestamp']
-                    text = chunk['text'].strip()
-                    
-                    if text:
-                        f.write(f"{i}\n")
-                        f.write(f"{format_srt_time(start)} --> {format_srt_time(end)}\n")
-                        f.write(f"{text}\n\n")
-            
-            print(f"SRT file write completed")
-        except Exception as e:
-            print(f"Error writing SRT file: {e}")
-            import traceback
-            print(traceback.format_exc())
-            shutil.rmtree(output_dir)
-            raise
         
-        # Verify SRT was created
-        print(f"Checking if SRT exists: {os.path.exists(srt_path)}")
-        print(f"Output directory contents after SRT: {os.listdir(output_dir)}")
+        with open(srt_path, 'w', encoding='utf-8-sig') as f:
+            for i, chunk in enumerate(transcription_result['chunks'], 1):
+                start, end = chunk['timestamp']
+                text = chunk['text'].strip()
+                
+                if text:
+                    f.write(f"{i}\n")
+                    f.write(f"{format_srt_time(start)} --> {format_srt_time(end)}\n")
+                    f.write(f"{text}\n\n")
         
+        # Verify SRT was created
         if not os.path.exists(srt_path):
-            shutil.rmtree(output_dir)
-            return None, None, f"SRT file was not created at: {srt_path}\nDirectory contents: {os.listdir(output_dir)}"
+            shutil.rmtree(temp_dir, ignore_errors=True)
+            shutil.rmtree(output_dir, ignore_errors=True)
+            return None, None, f"SRT file was not created at: {srt_path}"
         
         srt_size = os.path.getsize(srt_path)
         if srt_size == 0:
-            shutil.rmtree(output_dir)
+            shutil.rmtree(temp_dir, ignore_errors=True)
+            shutil.rmtree(output_dir, ignore_errors=True)
             return None, None, f"SRT file is empty at: {srt_path}"
         
         print(f"SRT created successfully: {srt_path} ({srt_size} bytes)")
         
-        # Read SRT content for debugging
-        try:
-            with open(srt_path, 'r', encoding='utf-8-sig') as f:
-                srt_preview = f.read()[:500]
-                print(f"SRT preview:\n{srt_preview}")
-        except Exception as e:
-            print(f"Error reading SRT file: {e}")
-        
         # Burn subtitles
         progress(0.85, desc="Burning subtitles...")
         output_path = os.path.join(output_dir, "final.mp4")
@@ -158,193 +140,20 @@ def process_video(video_file, language="hindi", progress=gr.Progress()):
         ass_path = os.path.join(output_dir, "subtitles.ass")
         
         print(f"Converting SRT to ASS for better compatibility...")
-        try:
-            subprocess.run([
-                'ffmpeg', '-y',
-                '-i', srt_path,
-                ass_path
-            ], check=True, capture_output=True, text=True)
-            
-            if not os.path.exists(ass_path):
-                raise Exception(f"Failed to create ASS file at {ass_path}")
-            
-            print(f"ASS file created: {ass_path} ({os.path.getsize(ass_path)} bytes)")
-        except subprocess.CalledProcessError as e:
-            print(f"SRT to ASS conversion failed: {e.stderr}")
-            shutil.rmtree(output_dir)
-            raise
-        
-        # Use ASS filter which is more reliable than subtitles filter
-        # For ass filter, we need to escape special characters differently
-        ass_path_escaped = ass_path.replace('\\', '\\\\').replace(':', '\\:')
-        
-        ffmpeg_cmd = [
+        subprocess.run([
             'ffmpeg', '-y',
-            '-i', video_file,
-            '-vf', f"ass={ass_path_escaped}",
-            '-c:a', 'copy',
-            '-c:v', 'libx264',
-            '-preset', 'medium',
-            '-crf', '23',
-            output_path
-        ]
+            '-i', srt_path,
+            ass_path
+        ], check=True, capture_output=True, text=True)
         
-        print(f"FFmpeg command: {' '.join(ffmpeg_cmd)}")
-        
-        try:
-            ffmpeg_result = subprocess.run(
-                ffmpeg_cmd,
-                check=True,
-                capture_output=True,
-                text=True,
-                timeout=600
-            )
-            print(f"FFmpeg stdout: {ffmpeg_result.stdout}")
-            print(f"FFmpeg stderr: {ffmpeg_result.stderr}")
-        except subprocess.CalledProcessError as e:
-            print(f"FFmpeg failed!")
-            print(f"Return code: {e.returncode}")
-            print(f"Stdout: {e.stdout}")
-            print(f"Stderr: {e.stderr}")
-            shutil.rmtree(output_dir)
-            raise
-        
-        if not os.path.exists(output_path):
-            shutil.rmtree(output_dir)
-            return None, None, f"Output video was not created at: {output_path}"
-        
-        print(f"Video created: {output_path} ({os.path.getsize(output_path)} bytes)")
-        
-        progress(1.0, desc="Complete!")
-        
-        # Create status with preview
-        preview_lines = []
-        for i, chunk in enumerate(result['chunks'][:10], 1):
-            text = chunk['text'].strip()
-            start_time = chunk['timestamp'][0]
-            preview_lines.append(f"{i}. [{start_time:.1f}s] {text}")
-        
-        preview_text = "\n".join(preview_lines)
-        full_text = " ".join([c['text'].strip() for c in result['chunks']])
-        
-        status = f"""Processing Complete!
-Statistics:
-- Model: Whisper Large V3 Turbo
-- Device: {device}
-- Segments: {len(result['chunks'])}
-- Duration: {result['chunks'][-1]['timestamp'][1]:.1f}s
-- Language: {language}
-
-Preview (first 10 segments):
-{preview_text}
-
-Full Transcription:
-{full_text[:500]}{"..." if len(full_text) > 500 else ""}
-
-Files created successfully!
-"""
-        
-        # Don't cleanup output_dir - Gradio needs these files
-        return srt_path, output_path, status
-        
-    except subprocess.TimeoutExpired:
-        try:
+        if not os.path.exists(ass_path):
             shutil.rmtree(temp_dir, ignore_errors=True)
             shutil.rmtree(output_dir, ignore_errors=True)
-        except:
-            pass
-        return None, None, "Processing timeout. Try a shorter video."
-    except subprocess.CalledProcessError as e:
-        try:
-            shutil.rmtree(temp_dir, ignore_errors=True)
-            shutil.rmtree(output_dir, ignore_errors=True)
-        except:
-            pass
-        error_detail = e.stderr.decode() if hasattr(e.stderr, 'decode') else str(e.stderr) if e.stderr else str(e)
-        return None, None, f"FFmpeg error: {error_detail}"
-    except Exception as e:
-        try:
-            shutil.rmtree(temp_dir, ignore_errors=True)
-            shutil.rmtree(output_dir, ignore_errors=True)
-        except:
-            pass
-        import traceback
-        error_trace = traceback.format_exc()
-        print(f"Error: {error_trace}")
-        return None, None, f"Error: {str(e)}\n\nDetails:\n{error_trace}"
-    finally:
-        # Only cleanup temp_dir (audio processing), keep output_dir for Gradio
-        try:
-            shutil.rmtree(temp_dir)
-            print(f"Cleaned up temp directory: {temp_dir}")
-        except Exception as e:
-            print(f"Cleanup warning: {e}")
-        # Note: output_dir is NOT cleaned up here - Gradio needs access to the files
-        # The files will be cleaned up by the OS eventually from /tmp/, 'w', encoding='utf-8-sig') as f:
-                for i, chunk in enumerate(result['chunks'], 1):
-                    start, end = chunk['timestamp']
-                    text = chunk['text'].strip()
-                    
-                    if text:
-                        f.write(f"{i}\n")
-                        f.write(f"{format_srt_time(start)} --> {format_srt_time(end)}\n")
-                        f.write(f"{text}\n\n")
-            
-            print(f"SRT file write completed")
-        except Exception as e:
-            print(f"Error writing SRT file: {e}")
-            import traceback
-            print(traceback.format_exc())
-            raise
-        
-        # Verify SRT was created
-        print(f"Checking if SRT exists: {os.path.exists(srt_path)}")
-        print(f"Temp directory contents after SRT: {os.listdir(temp_dir)}")
+            raise Exception(f"Failed to create ASS file at {ass_path}")
         
-        if not os.path.exists(srt_path):
-            return None, None, f"SRT file was not created at: {srt_path}\nDirectory contents: {os.listdir(temp_dir)}"
+        print(f"ASS file created: {ass_path} ({os.path.getsize(ass_path)} bytes)")
         
-        srt_size = os.path.getsize(srt_path)
-        if srt_size == 0:
-            return None, None, f"SRT file is empty at: {srt_path}"
-        
-        print(f"SRT created successfully: {srt_path} ({srt_size} bytes)")
-        
-        # Read SRT content for debugging
-        try:
-            with open(srt_path, 'r', encoding='utf-8-sig') as f:
-                srt_preview = f.read()[:500]
-                print(f"SRT preview:\n{srt_preview}")
-        except Exception as e:
-            print(f"Error reading SRT file: {e}")
-        
-        # Burn subtitles
-        progress(0.85, desc="Burning subtitles...")
-        output_path = os.path.join(temp_dir, "final.mp4")
-        
-        print("Burning subtitles with FFmpeg...")
-        
-        # Convert SRT to ASS first (more reliable with FFmpeg)
-        ass_path = os.path.join(temp_dir, "subtitles.ass")
-        
-        print(f"Converting SRT to ASS for better compatibility...")
-        try:
-            subprocess.run([
-                'ffmpeg', '-y',
-                '-i', srt_path,
-                ass_path
-            ], check=True, capture_output=True, text=True)
-            
-            if not os.path.exists(ass_path):
-                raise Exception(f"Failed to create ASS file at {ass_path}")
-            
-            print(f"ASS file created: {ass_path} ({os.path.getsize(ass_path)} bytes)")
-        except subprocess.CalledProcessError as e:
-            print(f"SRT to ASS conversion failed: {e.stderr}")
-            raise
-        
-        # Use ASS filter which is more reliable than subtitles filter
-        # For ass filter, we need to escape special characters differently
+        # Use ASS filter - escape path for FFmpeg
         ass_path_escaped = ass_path.replace('\\', '\\\\').replace(':', '\\:')
         
         ffmpeg_cmd = [
@@ -360,24 +169,17 @@ Files created successfully!
         
         print(f"FFmpeg command: {' '.join(ffmpeg_cmd)}")
         
-        try:
-            ffmpeg_result = subprocess.run(
-                ffmpeg_cmd,
-                check=True,
-                capture_output=True,
-                text=True,
-                timeout=600
-            )
-            print(f"FFmpeg stdout: {ffmpeg_result.stdout}")
-            print(f"FFmpeg stderr: {ffmpeg_result.stderr}")
-        except subprocess.CalledProcessError as e:
-            print(f"FFmpeg failed!")
-            print(f"Return code: {e.returncode}")
-            print(f"Stdout: {e.stdout}")
-            print(f"Stderr: {e.stderr}")
-            raise
+        subprocess.run(
+            ffmpeg_cmd,
+            check=True,
+            capture_output=True,
+            text=True,
+            timeout=600
+        )
         
         if not os.path.exists(output_path):
+            shutil.rmtree(temp_dir, ignore_errors=True)
+            shutil.rmtree(output_dir, ignore_errors=True)
             return None, None, f"Output video was not created at: {output_path}"
         
         print(f"Video created: {output_path} ({os.path.getsize(output_path)} bytes)")
@@ -386,20 +188,20 @@ Files created successfully!
         
         # Create status with preview
         preview_lines = []
-        for i, chunk in enumerate(result['chunks'][:10], 1):
+        for i, chunk in enumerate(transcription_result['chunks'][:10], 1):
             text = chunk['text'].strip()
             start_time = chunk['timestamp'][0]
             preview_lines.append(f"{i}. [{start_time:.1f}s] {text}")
         
         preview_text = "\n".join(preview_lines)
-        full_text = " ".join([c['text'].strip() for c in result['chunks']])
+        full_text = " ".join([c['text'].strip() for c in transcription_result['chunks']])
         
         status = f"""Processing Complete!
 Statistics:
 - Model: Whisper Large V3 Turbo
 - Device: {device}
-- Segments: {len(result['chunks'])}
-- Duration: {result['chunks'][-1]['timestamp'][1]:.1f}s
+- Segments: {len(transcription_result['chunks'])}
+- Duration: {transcription_result['chunks'][-1]['timestamp'][1]:.1f}s
 - Language: {language}
 
 Preview (first 10 segments):
@@ -411,25 +213,29 @@ Full Transcription:
 Files created successfully!
 """
         
+        # Cleanup only temp_dir, keep output_dir for Gradio
+        shutil.rmtree(temp_dir, ignore_errors=True)
+        print(f"Cleaned up temp directory: {temp_dir}")
+        
+        # Return paths - Gradio needs these files to exist
         return srt_path, output_path, status
         
     except subprocess.TimeoutExpired:
+        shutil.rmtree(temp_dir, ignore_errors=True)
+        shutil.rmtree(output_dir, ignore_errors=True)
         return None, None, "Processing timeout. Try a shorter video."
     except subprocess.CalledProcessError as e:
-        error_detail = e.stderr.decode() if hasattr(e.stderr, 'decode') else str(e.stderr) if e.stderr else str(e)
+        shutil.rmtree(temp_dir, ignore_errors=True)
+        shutil.rmtree(output_dir, ignore_errors=True)
+        error_detail = e.stderr if hasattr(e, 'stderr') else str(e)
         return None, None, f"FFmpeg error: {error_detail}"
     except Exception as e:
+        shutil.rmtree(temp_dir, ignore_errors=True)
+        shutil.rmtree(output_dir, ignore_errors=True)
         import traceback
         error_trace = traceback.format_exc()
         print(f"Error: {error_trace}")
         return None, None, f"Error: {str(e)}\n\nDetails:\n{error_trace}"
-    finally:
-        # Cleanup
-        try:
-            shutil.rmtree(temp_dir)
-            print(f"Cleaned up temp directory: {temp_dir}")
-        except Exception as e:
-            print(f"Cleanup warning: {e}")
 
 # Gradio UI
 with gr.Blocks(theme=gr.themes.Soft(), title="Hindi Subtitle Generator") as demo: