Update app.py

app.py

@@ -4,7 +4,6 @@ import subprocess
 import uuid
 import shutil
 import zipfile
-import time
 from datetime import datetime
 import pandas as pd
 
@@ -13,16 +12,12 @@ OUTPUT_DIR = "outputs"
 os.makedirs(OUTPUT_DIR, exist_ok=True)
 
 def map_level_to_crf(level: str) -> int:
-    """
-    Map user-friendly compression levels to FFmpeg CRF values.
-    Lower CRF = higher quality, higher file size.
-    """
     level = (level or "Medium").strip().lower()
-    if level == "low":        # Low compression (better quality)
+    if level == "low":
         return 22
-    elif level == "high":     # High compression (smaller size)
+    elif level == "high":
         return 32
-    else:                     # Medium (default)
+    else:
         return 28
 
 def ffmpeg_available() -> bool:
@@ -32,29 +27,13 @@ def ffmpeg_available() -> bool:
     except Exception:
         return False
 
-def compress_single_video(
-    infile_path: str,
-    crf: int,
-    preset: str = "fast",
-    audio_bitrate_kbps: int = 128,
-    progress: gr.Progress | None = None
-) -> tuple[str, int, int]:
-    """
-    Compress a single MP4 using ffmpeg (H.264, AAC).
-    Returns: (output_path, original_size_bytes, compressed_size_bytes)
-    """
-    # Build output filename
+def compress_single_video(infile_path: str, crf: int, preset: str = "fast", audio_bitrate_kbps: int = 128, progress=None):
     base = os.path.basename(infile_path)
-    name, ext = os.path.splitext(base)
-    out_name = f"{name}_compressed_{uuid.uuid4().hex[:8]}.mp4"
+    out_name = f"{os.path.splitext(base)[0]}_compressed_{uuid.uuid4().hex[:8]}.mp4"
     out_path = os.path.join(OUTPUT_DIR, out_name)
 
     original_size = os.path.getsize(infile_path)
 
-    # FFmpeg command
-    # -crf controls quality (18-28 typical; 32 more aggressive)
-    # -preset trades encode speed vs compression efficiency
-    # Audio is encoded to AAC with specified bitrate
     cmd = [
         "ffmpeg", "-y",
         "-i", infile_path,
@@ -65,97 +44,50 @@ def compress_single_video(
         out_path
     ]
 
-    # Progress: start
-    if progress is not None:
-        progress(0.2, desc=f"Compressing {base} (CRF {crf}, preset {preset})")
+    if progress:
+        progress(0.2, desc=f"Compressing {base}...")
 
-    # Run ffmpeg
     proc = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
     if proc.returncode != 0:
-        # Surface ffmpeg error
-        raise RuntimeError(
-            f"FFmpeg failed on {base}.\n\nSTDERR:\n{proc.stderr.decode(errors='ignore')}\n\nSTDOUT:\n{proc.stdout.decode(errors='ignore')}"
-        )
+        raise RuntimeError(f"FFmpeg failed on {base}:\n{proc.stderr.decode(errors='ignore')}")
 
     compressed_size = os.path.getsize(out_path)
-
-    if progress is not None:
+    if progress:
         progress(0.95, desc=f"Finalizing {base}")
 
     return out_path, original_size, compressed_size
 
-def validate_inputs(files: list) -> list[str]:
-    """
-    Validate and normalize input files into local paths.
-    """
+def validate_inputs(files):
     if not files or len(files) == 0:
         raise gr.Error("Please upload at least one MP4 file.")
-
-    # Gradio returns objects with .name when using gr.Files
     paths = []
     for f in files:
-        # f can be a tempfile-like object or a dict depending on Gradio version
         path = getattr(f, "name", None) or (isinstance(f, dict) and f.get("name")) or None
-        if not path:
-            raise gr.Error("Could not read uploaded file path.")
-        if not path.lower().endswith(".mp4"):
-            raise gr.Error(f"Unsupported file type: {os.path.basename(path)}. Please upload .mp4 only.")
+        if not path or not path.lower().endswith(".mp4"):
+            raise gr.Error(f"Invalid file: {path}")
         paths.append(path)
     return paths
 
-def compress_videos(
-    files,
-    level: str,
-    use_advanced: bool,
-    crf_value: int,
-    preset: str,
-    audio_bitrate_kbps: int,
-    progress: gr.Progress = gr.Progress()
-):
-    """
-    Main handler for multi-file compression with progress and reporting.
-    Returns:
-      - zip_path: ZIP containing all compressed videos + CSV report
-      - summary_df: DataFrame with per-file stats
-      - out_files: list of compressed file paths (for direct downloads)
-    """
-    # Quick check for ffmpeg
+def compress_videos(files, level, use_advanced, crf_value, preset, audio_bitrate_kbps, progress=gr.Progress()):
     if not ffmpeg_available():
-        raise gr.Error(
-            "FFmpeg is not available in this environment. "
-            "Please ensure 'ffmpeg' is installed via packages.txt."
-        )
+        raise gr.Error("FFmpeg is not installed. Add it in packages.txt.")
 
     input_paths = validate_inputs(files)
-
     total_files = len(input_paths)
-    progress(0, desc=f"Starting compression for {total_files} file(s)…")
+    progress(0, desc=f"Starting compression for {total_files} file(s)...")
 
-    # Resolve CRF
-    crf = crf_value if use_advanced else map_level_to_crf(level or "Medium")
-    # Resolve preset
+    crf = crf_value if use_advanced else map_level_to_crf(level)
     preset = preset or "fast"
     audio_bitrate_kbps = max(64, int(audio_bitrate_kbps or 128))
 
-    # Prepare report
     records = []
     compressed_paths = []
 
-    # Process files sequentially with coarse progress
     for idx, in_path in enumerate(input_paths, start=1):
         base = os.path.basename(in_path)
         try:
-            progress(
-                (idx - 1) / total_files,
-                desc=f"[{idx}/{total_files}] Preparing {base}"
-            )
-            out_path, orig_size, comp_size = compress_single_video(
-                infile_path=in_path,
-                crf=crf,
-                preset=preset,
-                audio_bitrate_kbps=audio_bitrate_kbps,
-                progress=progress
-            )
+            progress((idx - 1) / total_files, desc=f"[{idx}/{total_files}] Processing {base}")
+            out_path, orig_size, comp_size = compress_single_video(in_path, crf, preset, audio_bitrate_kbps, progress)
             reduction_bytes = orig_size - comp_size
             reduction_pct = (reduction_bytes / orig_size * 100.0) if orig_size > 0 else 0.0
             records.append({
@@ -167,12 +99,8 @@ def compress_videos(
                 "Output": os.path.basename(out_path)
             })
             compressed_paths.append(out_path)
-            progress(
-                idx / total_files,
-                desc=f"[{idx}/{total_files}] Completed {base} (↓ {round(reduction_pct,2)}%)"
-            )
+            progress(idx / total_files, desc=f"[{idx}/{total_files}] Done {base}")
         except Exception as e:
-            # Log failure in report
             records.append({
                 "File": base,
                 "Original Size (MB)": None,
@@ -182,87 +110,43 @@ def compress_videos(
                 "Output": f"ERROR: {str(e).splitlines()[0][:180]}"
             })
 
-    # Build summary dataframe
     df = pd.DataFrame.from_records(records)
-
-    # Save CSV report
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
     report_name = f"compression_report_{timestamp}.csv"
     report_path = os.path.join(OUTPUT_DIR, report_name)
     df.to_csv(report_path, index=False)
 
-    # Create ZIP bundle of outputs + report
     zip_name = f"compressed_bundle_{timestamp}.zip"
     zip_path = os.path.join(OUTPUT_DIR, zip_name)
     with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as zf:
-        # Add report
         zf.write(report_path, arcname=report_name)
-        # Add each compressed video
         for p in compressed_paths:
             zf.write(p, arcname=os.path.basename(p))
 
-    # Final progress
     progress(1.0, desc="All done! Download your results below.")
-
-    # Return ZIP (for one-click download), summary table, and individual files (for selective downloads)
     return zip_path, df, compressed_paths
 
-with gr.Blocks() as demo:
+with gr.Blocks(css=".summary-table {max-height: 260px; overflow-y: auto;}") as demo:
     gr.Markdown("# 🎥 MP4 Video Compressor (Multi-file)")
-    gr.Markdown(
-        "Upload one or more MP4s, choose compression level, and get the compressed files.\n"
-        "Includes a progress bar and a CSV summary (sizes & reduction)."
-    )
+    gr.Markdown("Upload MP4 videos, choose compression level, and download compressed files with a summary report.")
 
     with gr.Row():
         with gr.Column():
-            files_in = gr.Files(
-                label="Upload MP4 Videos",
-                file_count="multiple",
-                file_types=[".mp4"],
-                height=120
-            )
-
-            # Simple compression level
-            level = gr.Radio(
-                label="Compression Level",
-                choices=["Low", "Medium", "High"],
-                value="Medium",
-                info="Low = best quality, High = smallest files"
-            )
-
-            with gr.Accordion("Advanced Options (optional)", open=False):
+            files_in = gr.Files(label="Upload MP4 Videos", file_count="multiple", file_types=[".mp4"])
+            level = gr.Radio(label="Compression Level", choices=["Low", "Medium", "High"], value="Medium")
+            with gr.Accordion("Advanced Options", open=False):
                 use_adv = gr.Checkbox(label="Use advanced settings", value=False)
-                crf_val = gr.Slider(
-                    minimum=18, maximum=36, step=1, value=28, label="CRF (Quality/Compression)"
-                )
-                preset = gr.Dropdown(
-                    label="FFmpeg Preset",
-                    choices=["ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow"],
-                    value="fast",
-                    allow_custom_value=False
-                )
-                audio_bitrate = gr.Slider(
-                    minimum=64, maximum=320, step=16, value=128, label="Audio Bitrate (kbps)"
-                )
-
+                crf_val = gr.Slider(minimum=18, maximum=36, step=1, value=28, label="CRF")
+                preset = gr.Dropdown(label="FFmpeg Preset", choices=["ultrafast","superfast","veryfast","faster","fast","medium","slow","slower","veryslow"], value="fast")
+                audio_bitrate = gr.Slider(minimum=64, maximum=320, step=16, value=128, label="Audio Bitrate (kbps)")
             run_btn = gr.Button("🔄 Compress", variant="primary")
 
         with gr.Column():
-            zip_out = gr.File(label="Download ZIP (compressed videos + CSV report)")
-            summary = gr.Dataframe(
-                label="Compression Summary",
-                interactive=False,
-                wrap=True,
-                height=260
-            )
+            zip_out = gr.File(label="Download ZIP (videos + report)")
+            summary = gr.Dataframe(label="Compression Summary", interactive=False, wrap=True, elem_classes="summary-table")
             files_out = gr.Files(label="Download Individual Compressed Files")
 
-    run_btn.click(
-        fn=compress_videos,
-        inputs=[files_in, level, use_adv, crf_val, preset, audio_bitrate],
-        outputs=[zip_out, summary, files_out]
-    )
+    run_btn.click(fn=compress_videos, inputs=[files_in, level, use_adv, crf_val, preset, audio_bitrate], outputs=[zip_out, summary, files_out])
 
 if __name__ == "__main__":
     demo.launch()