Update streamlit_app.py

streamlit_app.py

@@ -69,26 +69,49 @@ def _file_sha256(path: Path) -> Optional[str]:
 
 
 def _convert_to_mp4(src: Path) -> Path:
-    # Use a more robust way to generate the destination name, preserving original stem
-    dst = src.parent / f"{src.stem}.mp4"
-    if dst.exists() and dst.stat().st_size > 0: # Check if already converted and not empty
-        src.unlink(missing_ok=True) # Remove source if conversion already exists
+    # 1. Check if source file exists and is not empty
+    if not src.exists():
+        raise FileNotFoundError(f"Source file '{src.name}' for MP4 conversion not found.")
+    if src.stat().st_size == 0:
+        raise ValueError(f"Source file '{src.name}' for MP4 conversion is empty.")
+
+    # 2. Determine destination path. If source is already MP4, destination is source.
+    if src.suffix.lower() == ".mp4":
+        dst = src
+    else:
+        dst = src.parent / f"{src.stem}.mp4"
+
+    # 3. If destination already exists and is non-empty, assume conversion is done or it was already MP4.
+    if dst.exists() and dst.stat().st_size > 0:
+        if src != dst: # Only unlink if src is a different, non-MP4 file that was converted
+            src.unlink(missing_ok=True)
         return dst
+
+    # 4. Perform conversion if necessary
     try:
-        ffmpeg.input(str(src)).output(str(dst)).overwrite_output().run(
+        # Use a temporary file for output to prevent partial files if conversion fails
+        temp_dst = dst.with_suffix(".mp4.tmp")
+        ffmpeg.input(str(src)).output(str(temp_dst)).overwrite_output().run(
             capture_stdout=True, capture_stderr=True
         )
+        # If successful, rename temp file to final destination
+        temp_dst.rename(dst)
     except ffmpeg.Error as e:
-        # Include stderr in the error message for better debugging
+        # Ensure temp file is cleaned up on error
+        temp_dst.unlink(missing_ok=True)
         error_msg = e.stderr.decode()
         raise RuntimeError(f"ffmpeg conversion failed for {src.name}: {error_msg}") from e
+    except Exception as e: # Catch other potential errors during ffmpeg setup or execution
+        temp_dst.unlink(missing_ok=True)
+        raise RuntimeError(f"An unexpected error occurred during ffmpeg conversion for {src.name}: {e}") from e
 
+    # 5. Final check and cleanup
     if dst.exists() and dst.stat().st_size > 0:
-        src.unlink() # Only unlink if conversion was successful and resulted in a non-empty file
+        if src != dst: # Only unlink the original file if it was converted to a new file
+            src.unlink(missing_ok=True)
+        return dst
     else:
-        # If conversion failed silently (no error but no output), raise a specific error
-        raise RuntimeError(f"ffmpeg conversion for {src.name} produced an empty or missing MP4 file.")
-    return dst
+        raise RuntimeError(f"ffmpeg conversion for {src.name} produced an empty or missing MP4 file (final check).")
 
 
 def _compress_video(inp: Path, crf: int = 28, preset: str = "fast") -> Path:
@@ -106,6 +129,10 @@ def _compress_video(inp: Path, crf: int = 28, preset: str = "fast") -> Path:
 
 
 def _maybe_compress(path: Path, limit_mb: int) -> Tuple[Path, bool]:
+    # Ensure the path exists before trying to stat it, though _convert_to_mp4 should already guarantee this.
+    if not path.exists() or path.stat().st_size == 0:
+        raise FileNotFoundError(f"Video file for compression not found or is empty: {path.name}")
+
     size_mb = path.stat().st_size / (1024 * 1024)
     if size_mb <= limit_mb:
         return path, False
@@ -140,6 +167,10 @@ def _download_direct(url: str, dst: Path) -> Path:
         for chunk in r.iter_content(chunk_size=8192):
             if chunk:
                 f.write(chunk)
+    # Ensure the downloaded file is not empty
+    if not out_path.exists() or out_path.stat().st_size == 0:
+        out_path.unlink(missing_ok=True)
+        raise RuntimeError(f"Direct download of '{url}' resulted in an empty or failed file.")
     return out_path
 
 
@@ -202,9 +233,13 @@ def _download_with_yt_dlp(url: str, dst: Path, password: str = "") -> Path:
             if downloaded_file is None:
                 # yt_dlp might move/rename files, so checking `info['_filename']` is reliable
                 downloaded_file = Path(info.get('_filename', ''))
-                # If it's still not an MP4, try to convert it
-                if downloaded_file.suffix.lower() != ".mp4":
-                    downloaded_file = _convert_to_mp4(downloaded_file)
+
+            # Ensure the file exists and is not empty before attempting conversion
+            if downloaded_file.exists() and downloaded_file.stat().st_size > 0:
+                # If it's still not an MP4, convert it. If it is, _convert_to_mp4 will handle it.
+                downloaded_file = _convert_to_mp4(downloaded_file)
+            else:
+                raise RuntimeError(f"yt-dlp download for '{url}' produced an empty or missing file.")
 
     finally:
         bar.empty()
@@ -212,9 +247,8 @@ def _download_with_yt_dlp(url: str, dst: Path, password: str = "") -> Path:
 
     if downloaded_file and downloaded_file.exists() and downloaded_file.stat().st_size > 0:
         # Ensure it's an MP4, even if yt_dlp hook didn't catch final MP4 name
-        if downloaded_file.suffix.lower() != ".mp4":
-            return _convert_to_mp4(downloaded_file)
-        return downloaded_file
+        # _convert_to_mp4 is idempotent and handles this already.
+        return _convert_to_mp4(downloaded_file)
 
     # ---------- Fallback: direct HTTP download ----------
     st.warning("yt-dlp failed or did not produce an MP4, attempting direct download.")
@@ -509,7 +543,8 @@ def main() -> None:
                         raw_path = download_video(
                             st.session_state["url"], DATA_DIR, st.session_state["video_password"]
                         )
-                        mp4_path = _convert_to_mp4(Path(raw_path)) # Ensure it's MP4
+                        # Ensure it's MP4 - _convert_to_mp4 is now idempotent and robust
+                        mp4_path = _convert_to_mp4(raw_path) 
                         st.session_state["video_path"], was_compressed = _maybe_compress(mp4_path, st.session_state["compress_mb"])
                         if was_compressed:
                             st.toast("Video downloaded and compressed.")
@@ -521,6 +556,7 @@ def main() -> None:
                     RuntimeError,
                     requests.exceptions.RequestException,
                     yt_dlp.utils.DownloadError,
+                    FileNotFoundError, # Added to catch explicit FileNotFoundError from _convert_to_mp4 or _maybe_compress
                 ) as e:
                     st.session_state["last_error"] = f"Download failed: {e}"
                     st.session_state["last_error_detail"] = traceback.format_exc()