talks-reducer 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

talks_reducer/__about__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.4.0"
+__version__ = "0.5.0"

talks_reducer/cli.py

@@ -63,7 +63,7 @@ def _build_parser() -> argparse.ArgumentParser:
         "--silent_threshold",
         type=float,
         dest="silent_threshold",
-        help="The volume amount that frames' audio needs to surpass to be considered sounded. Defaults to 0.03.",
+        help="The volume amount that frames' audio needs to surpass to be considered sounded. Defaults to 0.05.",
     )
     parser.add_argument(
         "-S",
@@ -143,6 +143,22 @@ def _launch_gui(argv: Sequence[str]) -> bool:
     return bool(gui_main(list(argv)))
 
 
+def _launch_server(argv: Sequence[str]) -> bool:
+    """Attempt to launch the Gradio web server with the provided arguments."""
+
+    try:
+        server_module = import_module(".server", __package__)
+    except ImportError:
+        return False
+
+    server_main = getattr(server_module, "main", None)
+    if server_main is None:
+        return False
+
+    server_main(list(argv))
+    return True
+
+
 def main(argv: Optional[Sequence[str]] = None) -> None:
     """Entry point for the command line interface.
 
@@ -154,6 +170,12 @@ def main(argv: Optional[Sequence[str]] = None) -> None:
     else:
         argv_list = list(argv)
 
+    if argv_list and argv_list[0] in {"server", "serve"}:
+        if not _launch_server(argv_list[1:]):
+            print("Gradio server mode is unavailable.", file=sys.stderr)
+            sys.exit(1)
+        return
+
     if not argv_list:
         if _launch_gui(argv_list):
             return
@@ -200,7 +222,6 @@ def main(argv: Optional[Sequence[str]] = None) -> None:
             option_kwargs["sample_rate"] = int(local_options["sample_rate"])
         if "small" in local_options:
             option_kwargs["small"] = bool(local_options["small"])
-
         options = ProcessingOptions(**option_kwargs)
 
         try:

talks_reducer/ffmpeg.py

@@ -242,11 +242,29 @@ def run_timed_ffmpeg_command(
             if not line:
                 continue
 
-            sys.stderr.write(line)
-            sys.stderr.flush()
-
-            # Send FFmpeg output to reporter for GUI display
-            progress_reporter.log(line.strip())
+            # Filter out excessive progress output, only show important lines
+            if any(
+                keyword in line.lower()
+                for keyword in [
+                    "error",
+                    "warning",
+                    "encoded successfully",
+                    "frame=",
+                    "time=",
+                    "size=",
+                    "bitrate=",
+                    "speed=",
+                ]
+            ):
+                sys.stderr.write(line)
+                sys.stderr.flush()
+
+            # Send FFmpeg output to reporter for GUI display (filtered)
+            if any(
+                keyword in line.lower()
+                for keyword in ["error", "warning", "encoded successfully", "frame="]
+            ):
+                progress_reporter.log(line.strip())
 
             match = re.search(r"frame=\s*(\d+)", line)
             if match:
@@ -365,7 +383,11 @@ def build_video_commands(
             # Use a fast software encoder instead
             video_encoder_args = ["-c:v libx264", "-preset veryfast", "-crf 23"]
 
-    audio_parts = ["-c:a aac", f'"{output_file}"', "-loglevel info -stats -hide_banner"]
+    audio_parts = [
+        "-c:a aac",
+        f'"{output_file}"',
+        "-loglevel warning -stats -hide_banner",
+    ]
 
     full_command_parts = (
         global_parts + input_parts + output_parts + video_encoder_args + audio_parts

talks_reducer/gui.py

@@ -200,6 +200,7 @@ class _TkProgressReporter(SignalProgressReporter):
 
     def log(self, message: str) -> None:
         self._log_callback(message)
+        print(message, flush=True)
 
     def task(
         self, *, desc: str = "", total: Optional[int] = None, unit: str = ""
@@ -256,7 +257,12 @@ class TalksReducerGUI:
         self._settings[key] = value
         self._save_settings()
 
-    def __init__(self) -> None:
+    def __init__(
+        self,
+        initial_inputs: Optional[Sequence[str]] = None,
+        *,
+        auto_run: bool = False,
+    ) -> None:
         self._config_path = self._determine_config_path()
         self._settings = self._load_settings()
 
@@ -284,8 +290,8 @@ class TalksReducerGUI:
 
         self._apply_window_icon()
 
-        self._full_size = (760, 680)
-        self._simple_size = (255, 330)
+        self._full_size = (1000, 800)
+        self._simple_size = (300, 270)
         self.root.geometry(f"{self._full_size[0]}x{self._full_size[1]}")
         self.style = self.ttk.Style(self.root)
 
@@ -298,6 +304,9 @@ class TalksReducerGUI:
         self._status_animation_job: Optional[str] = None
         self._status_animation_phase = 0
         self._video_duration_seconds: Optional[float] = None
+        self._encode_target_duration_seconds: Optional[float] = None
+        self._encode_total_frames: Optional[int] = None
+        self._encode_current_frame: Optional[int] = None
         self.progress_var = tk.IntVar(value=0)
         self._ffmpeg_process: Optional[subprocess.Popen] = None
         self._stop_requested = False
@@ -333,6 +342,9 @@ class TalksReducerGUI:
                 "Drag and drop requires the tkinterdnd2 package. Install it to enable the drop zone."
             )
 
+        if initial_inputs:
+            self._populate_initial_inputs(initial_inputs, auto_run=auto_run)
+
     # ------------------------------------------------------------------ UI --
     def _apply_window_icon(self) -> None:
         """Configure the application icon when the asset is available."""
@@ -423,7 +435,7 @@ class TalksReducerGUI:
 
         # Options frame
         options = self.ttk.Frame(main, padding=self.PADDING)
-        options.grid(row=2, column=0, pady=(16, 0), sticky="ew")
+        options.grid(row=2, column=0, pady=(0, 0), sticky="ew")
         options.columnconfigure(0, weight=1)
 
         checkbox_frame = self.ttk.Frame(options)
@@ -496,7 +508,7 @@ class TalksReducerGUI:
             self.advanced_frame, "Frame margin", self.frame_margin_var, row=5
         )
 
-        self.sample_rate_var = self.tk.StringVar()
+        self.sample_rate_var = self.tk.StringVar(value="48000")
         self._add_entry(self.advanced_frame, "Sample rate", self.sample_rate_var, row=6)
 
         self.ttk.Label(self.advanced_frame, text="Theme").grid(
@@ -862,6 +874,26 @@ class TalksReducerGUI:
         widget.drop_target_register(DND_FILES)  # type: ignore[arg-type]
         widget.dnd_bind("<<Drop>>", self._on_drop)  # type: ignore[attr-defined]
 
+    def _populate_initial_inputs(
+        self, inputs: Sequence[str], *, auto_run: bool = False
+    ) -> None:
+        """Seed the GUI with preselected inputs and optionally start processing."""
+
+        normalized: list[str] = []
+        for path in inputs:
+            if not path:
+                continue
+            resolved = os.fspath(Path(path))
+            if resolved not in self.input_files:
+                self.input_files.append(resolved)
+                self.input_list.insert(self.tk.END, resolved)
+                normalized.append(resolved)
+
+        if auto_run and normalized:
+            # Kick off processing once the event loop becomes idle so the
+            # interface has a chance to render before the work starts.
+            self.root.after_idle(self._start_run)
+
     # -------------------------------------------------------------- actions --
     def _ask_for_input_files(self) -> tuple[str, ...]:
         """Prompt the user to select input files for processing."""
@@ -1014,11 +1046,10 @@ class TalksReducerGUI:
                     self._append_log("Processing aborted by user.")
                     self._set_status("Aborted")
                 else:
-                    self._notify(
-                        lambda: self.messagebox.showerror(
-                            "Error", f"Processing failed: {exc}"
-                        )
-                    )
+                    error_msg = f"Processing failed: {exc}"
+                    self._append_log(error_msg)
+                    print(error_msg, file=sys.stderr)  # Also output to console
+                    self._notify(lambda: self.messagebox.showerror("Error", error_msg))
                     self._set_status("Error")
             finally:
                 self._notify(self._hide_stop_button)
@@ -1093,7 +1124,6 @@ class TalksReducerGUI:
             )
         if self.small_var.get():
             args["small"] = True
-
         return args
 
     def _parse_float(self, value: str, label: str) -> float:
@@ -1155,16 +1185,73 @@ class TalksReducerGUI:
             self._set_status("success", status_msg)
             self._set_progress(100)  # 100% on success
             self._video_duration_seconds = None  # Reset for next video
+            self._encode_target_duration_seconds = None
+            self._encode_total_frames = None
+            self._encode_current_frame = None
         elif normalized.startswith("extracting audio"):
             self._set_status("processing", "Extracting audio...")
             self._set_progress(0)  # 0% on start
             self._video_duration_seconds = None  # Reset for new processing
+            self._encode_target_duration_seconds = None
+            self._encode_total_frames = None
+            self._encode_current_frame = None
         elif normalized.startswith("starting processing") or normalized.startswith(
             "processing"
         ):
             self._set_status("processing", "Processing")
             self._set_progress(0)  # 0% on start
             self._video_duration_seconds = None  # Reset for new processing
+            self._encode_target_duration_seconds = None
+            self._encode_total_frames = None
+            self._encode_current_frame = None
+
+        frame_total_match = re.search(
+            r"Final encode target frames(?: \(fallback\))?:\s*(\d+)", message
+        )
+        if frame_total_match:
+            self._encode_total_frames = int(frame_total_match.group(1))
+            return
+
+        if "final encode target frames" in normalized and "unknown" in normalized:
+            self._encode_total_frames = None
+            return
+
+        frame_match = re.search(r"frame=\s*(\d+)", message)
+        if frame_match:
+            try:
+                current_frame = int(frame_match.group(1))
+            except ValueError:
+                current_frame = None
+
+            if current_frame is not None:
+                if self._encode_current_frame == current_frame:
+                    return
+
+                self._encode_current_frame = current_frame
+                if self._encode_total_frames and self._encode_total_frames > 0:
+                    percentage = min(
+                        100,
+                        int((current_frame / self._encode_total_frames) * 100),
+                    )
+                    self._set_progress(percentage)
+                else:
+                    self._set_status("processing", f"{current_frame} frames encoded")
+
+        # Parse encode target duration reported by the pipeline
+        encode_duration_match = re.search(
+            r"Final encode target duration(?: \(fallback\))?:\s*([\d.]+)s",
+            message,
+        )
+        if encode_duration_match:
+            try:
+                self._encode_target_duration_seconds = float(
+                    encode_duration_match.group(1)
+                )
+            except ValueError:
+                self._encode_target_duration_seconds = None
+
+        if "final encode target duration" in normalized and "unknown" in normalized:
+            self._encode_target_duration_seconds = None
 
         # Parse video duration from FFmpeg output
         duration_match = re.search(r"Duration:\s*(\d{2}):(\d{2}):(\d{2}\.\d+)", message)
@@ -1182,21 +1269,34 @@ class TalksReducerGUI:
             hours = int(time_match.group(1))
             minutes = int(time_match.group(2))
             seconds = int(time_match.group(3))
-            time_str = f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+            current_seconds = hours * 3600 + minutes * 60 + seconds
+            time_str = self._format_progress_time(current_seconds)
             speed_str = speed_match.group(1)
 
-            # Calculate percentage if we have duration
-            if self._video_duration_seconds and self._video_duration_seconds > 0:
-                current_seconds = hours * 3600 + minutes * 60 + seconds
-                percentage = min(
-                    100, int((current_seconds / self._video_duration_seconds) * 100)
-                )
-                self._set_status(
-                    "processing", f"{time_str}, {speed_str}x ({percentage}%)"
-                )
-                self._set_progress(percentage)  # Update progress bar
+            total_seconds = (
+                self._encode_target_duration_seconds or self._video_duration_seconds
+            )
+            if total_seconds:
+                total_str = self._format_progress_time(total_seconds)
+                time_display = f"{time_str} / {total_str}"
             else:
-                self._set_status("processing", f"{time_str}, {speed_str}x")
+                time_display = time_str
+
+            status_msg = f"{time_display}, {speed_str}x"
+
+            if (
+                (
+                    not self._encode_total_frames
+                    or self._encode_total_frames <= 0
+                    or self._encode_current_frame is None
+                )
+                and total_seconds
+                and total_seconds > 0
+            ):
+                percentage = min(100, int((current_seconds / total_seconds) * 100))
+                self._set_progress(percentage)
+
+            self._set_status("processing", status_msg)
 
     def _apply_status_style(self, status: str) -> None:
         color = STATUS_COLORS.get(status.lower())
@@ -1208,7 +1308,7 @@ class TalksReducerGUI:
             status_lower = status.lower()
             if (
                 "extracting audio" in status_lower
-                or re.search(r"\d{2}:\d{2}:\d{2}.*\d+\.?\d*x", status)
+                or re.search(r"\d+:\d{2}(?: / \d+:\d{2})?.*\d+\.?\d*x", status)
                 or ("time:" in status_lower and "size:" in status_lower)
             ):
                 if "time:" in status_lower and "size:" in status_lower:
@@ -1261,6 +1361,23 @@ class TalksReducerGUI:
 
         self.root.after(0, apply)
 
+    def _format_progress_time(self, total_seconds: float) -> str:
+        """Format a duration in seconds as h:mm or m:ss for status display."""
+
+        try:
+            rounded_seconds = max(0, int(round(total_seconds)))
+        except (TypeError, ValueError):
+            return "0:00"
+
+        hours, remainder = divmod(rounded_seconds, 3600)
+        minutes, seconds = divmod(remainder, 60)
+
+        if hours > 0:
+            return f"{hours}:{minutes:02d}"
+
+        total_minutes = rounded_seconds // 60
+        return f"{total_minutes}:{seconds:02d}"
+
     def _calculate_gradient_color(self, percentage: int, darken: float = 1.0) -> str:
         """Calculate color gradient from red (0%) to green (100%).
 
@@ -1377,6 +1494,24 @@ def main(argv: Optional[Sequence[str]] = None) -> bool:
         argv = sys.argv[1:]
 
     if argv:
+        launch_gui = False
+        if sys.platform == "win32" and not any(arg.startswith("-") for arg in argv):
+            # Only attempt to launch the GUI automatically when the arguments
+            # look like file or directory paths. This matches the behaviour of
+            # file association launches on Windows while still allowing the CLI
+            # to be used explicitly with option flags.
+            if any(Path(arg).exists() for arg in argv if arg):
+                launch_gui = True
+
+        if launch_gui:
+            try:
+                app = TalksReducerGUI(argv, auto_run=True)
+                app.run()
+                return True
+            except Exception:
+                # Fall back to the CLI if the GUI cannot be started.
+                pass
+
         cli_main(argv)
         return False
 

talks_reducer/models.py

@@ -18,8 +18,8 @@ class ProcessingOptions:
     input_file: Path
     output_file: Optional[Path] = None
     frame_rate: float = 30.0
-    sample_rate: int = 44100
-    silent_threshold: float = 0.03
+    sample_rate: int = 48000
+    silent_threshold: float = 0.05
     silent_speed: float = 4.0
     sounded_speed: float = 1.0
     frame_spreadage: int = 2

talks_reducer/pipeline.py

@@ -27,7 +27,15 @@ from .progress import NullProgressReporter, ProgressReporter
 
 def _input_to_output_filename(filename: Path, small: bool = False) -> Path:
     dot_index = filename.name.rfind(".")
-    suffix = "_speedup_small" if small else "_speedup"
+    suffix_parts = []
+
+    if small:
+        suffix_parts.append("_small")
+
+    if not suffix_parts:
+        suffix_parts.append("")  # Default case
+
+    suffix = "_speedup" + "".join(suffix_parts)
     new_name = (
         filename.name[:dot_index] + suffix + filename.name[dot_index:]
         if dot_index != -1
@@ -74,7 +82,7 @@ def _extract_video_metadata(input_file: Path, frame_rate: float) -> Dict[str, fl
         "-select_streams",
         "v",
         "-show_entries",
-        "format=duration:stream=avg_frame_rate",
+        "format=duration:stream=avg_frame_rate,nb_frames",
     ]
     process = subprocess.Popen(
         command,
@@ -92,7 +100,14 @@ def _extract_video_metadata(input_file: Path, frame_rate: float) -> Dict[str, fl
     match_duration = re.search(r"duration=([\d.]*)", str(stdout))
     original_duration = float(match_duration.group(1)) if match_duration else 0.0
 
-    return {"frame_rate": frame_rate, "duration": original_duration}
+    match_frames = re.search(r"nb_frames=(\d+)", str(stdout))
+    frame_count = int(match_frames.group(1)) if match_frames else 0
+
+    return {
+        "frame_rate": frame_rate,
+        "duration": original_duration,
+        "frame_count": frame_count,
+    }
 
 
 def _ensure_two_dimensional(audio_data: np.ndarray) -> np.ndarray:
@@ -135,6 +150,18 @@ def speed_up_video(
     metadata = _extract_video_metadata(input_path, options.frame_rate)
     frame_rate = metadata["frame_rate"]
     original_duration = metadata["duration"]
+    frame_count = metadata.get("frame_count", 0)
+
+    reporter.log(
+        (
+            "Source metadata — duration: {duration:.2f}s, frame rate: {fps:.3f} fps,"
+            " reported frames: {frames}"
+        ).format(
+            duration=original_duration,
+            fps=frame_rate,
+            frames=frame_count if frame_count > 0 else "unknown",
+        )
+    )
 
     reporter.log("Processing on: {}".format("GPU (CUDA)" if cuda_available else "CPU"))
     if options.small:
@@ -148,10 +175,12 @@ def speed_up_video(
     audio_bitrate = "128k" if options.small else "160k"
     audio_wav = temp_path / "audio.wav"
 
+    extraction_sample_rate = options.sample_rate
+
     extract_command = build_extract_audio_command(
         os.fspath(input_path),
         os.fspath(audio_wav),
-        options.sample_rate,
+        extraction_sample_rate,
         audio_bitrate,
         hwaccel,
         ffmpeg_path=ffmpeg_path,
@@ -159,10 +188,19 @@ def speed_up_video(
 
     reporter.log("Extracting audio...")
     process_callback = getattr(reporter, "process_callback", None)
+    estimated_total_frames = frame_count
+    if estimated_total_frames <= 0 and original_duration > 0 and frame_rate > 0:
+        estimated_total_frames = int(math.ceil(original_duration * frame_rate))
+
+    if estimated_total_frames > 0:
+        reporter.log(f"Extract audio target frames: {estimated_total_frames}")
+    else:
+        reporter.log("Extract audio target frames: unknown")
+
     run_timed_ffmpeg_command(
         extract_command,
         reporter=reporter,
-        total=int(original_duration * frame_rate),
+        total=estimated_total_frames if estimated_total_frames > 0 else None,
         unit="frames",
         desc="Extracting audio:",
         process_callback=process_callback,
@@ -202,9 +240,11 @@ def speed_up_video(
     )
 
     audio_new_path = temp_path / "audioNew.wav"
+    # Use the sample rate that was actually used for processing
+    output_sample_rate = extraction_sample_rate
     wavfile.write(
         os.fspath(audio_new_path),
-        options.sample_rate,
+        output_sample_rate,
         _prepare_output_audio(output_audio_data),
     )
 
@@ -246,10 +286,29 @@ def speed_up_video(
         raise FileNotFoundError("Filter graph file was not generated")
 
     try:
+        final_total_frames = updated_chunks[-1][3] if updated_chunks else 0
+        if final_total_frames > 0:
+            reporter.log(f"Final encode target frames: {final_total_frames}")
+            if frame_rate > 0:
+                final_duration_seconds = final_total_frames / frame_rate
+                reporter.log(
+                    (
+                        "Final encode target duration: {duration:.2f}s at {fps:.3f} fps"
+                    ).format(duration=final_duration_seconds, fps=frame_rate)
+                )
+            else:
+                reporter.log(
+                    "Final encode target duration: unknown (missing frame rate)"
+                )
+        else:
+            reporter.log("Final encode target frames: unknown")
+
+        total_frames_arg = final_total_frames if final_total_frames > 0 else None
+
         run_timed_ffmpeg_command(
             command_str,
             reporter=reporter,
-            total=updated_chunks[-1][3],
+            total=total_frames_arg,
             unit="frames",
             desc="Generating final:",
             process_callback=process_callback,
@@ -257,10 +316,25 @@ def speed_up_video(
     except subprocess.CalledProcessError as exc:
         if fallback_command_str and use_cuda_encoder:
             reporter.log("CUDA encoding failed, retrying with CPU encoder...")
+            if final_total_frames > 0:
+                reporter.log(
+                    f"Final encode target frames (fallback): {final_total_frames}"
+                )
+            else:
+                reporter.log("Final encode target frames (fallback): unknown")
+            if final_total_frames > 0 and frame_rate > 0:
+                reporter.log(
+                    (
+                        "Final encode target duration (fallback): {duration:.2f}s at {fps:.3f} fps"
+                    ).format(
+                        duration=final_total_frames / frame_rate,
+                        fps=frame_rate,
+                    )
+                )
             run_timed_ffmpeg_command(
                 fallback_command_str,
                 reporter=reporter,
-                total=updated_chunks[-1][3],
+                total=total_frames_arg,
                 unit="frames",
                 desc="Generating final (fallback):",
                 process_callback=process_callback,

talks_reducer/server.py

@@ -0,0 +1,353 @@
+"""Gradio-powered simple server for running Talks Reducer in a browser."""
+
+from __future__ import annotations
+
+import argparse
+import atexit
+import shutil
+import tempfile
+from contextlib import AbstractContextManager, suppress
+from pathlib import Path
+from typing import Callable, Optional, Sequence
+
+import gradio as gr
+
+from talks_reducer.ffmpeg import FFmpegNotFoundError
+from talks_reducer.models import ProcessingOptions, ProcessingResult
+from talks_reducer.pipeline import speed_up_video
+from talks_reducer.progress import ProgressHandle, SignalProgressReporter
+
+
+class _GradioProgressHandle(AbstractContextManager[ProgressHandle]):
+    """Translate pipeline progress updates into Gradio progress callbacks."""
+
+    def __init__(
+        self,
+        reporter: "GradioProgressReporter",
+        *,
+        desc: str,
+        total: Optional[int],
+        unit: str,
+    ) -> None:
+        self._reporter = reporter
+        self._desc = desc.strip() or "Processing"
+        self._unit = unit
+        self._total = total
+        self._current = 0
+        self._reporter._start_task(self._desc, self._total)
+
+    @property
+    def current(self) -> int:
+        """Return the number of processed units reported so far."""
+
+        return self._current
+
+    def ensure_total(self, total: int) -> None:
+        """Update the total units when FFmpeg discovers a larger frame count."""
+
+        if total > 0 and (self._total is None or total > self._total):
+            self._total = total
+            self._reporter._update_progress(self._current, self._total, self._desc)
+
+    def advance(self, amount: int) -> None:
+        """Advance the current progress and notify the UI."""
+
+        if amount <= 0:
+            return
+        self._current += amount
+        self._reporter._update_progress(self._current, self._total, self._desc)
+
+    def finish(self) -> None:
+        """Fill the progress bar when FFmpeg completes."""
+
+        if self._total is not None:
+            self._current = self._total
+        else:
+            # Without a known total, treat the final frame count as the total so the
+            # progress bar reaches 100%.
+            inferred_total = self._current if self._current > 0 else 1
+            self._reporter._update_progress(self._current, inferred_total, self._desc)
+            return
+        self._reporter._update_progress(self._current, self._total, self._desc)
+
+    def __enter__(self) -> "_GradioProgressHandle":
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> bool:
+        if exc_type is None:
+            self.finish()
+        return False
+
+
+class GradioProgressReporter(SignalProgressReporter):
+    """Progress reporter that forwards updates to Gradio's progress widget."""
+
+    def __init__(
+        self,
+        progress_callback: Optional[Callable[[int, int, str], None]] = None,
+        *,
+        max_log_lines: int = 500,
+    ) -> None:
+        super().__init__()
+        self._progress_callback = progress_callback
+        self._max_log_lines = max_log_lines
+        self._active_desc = "Processing"
+        self.logs: list[str] = []
+
+    def log(self, message: str) -> None:
+        """Collect log messages for display in the web interface."""
+
+        text = message.strip()
+        if not text:
+            return
+        self.logs.append(text)
+        if len(self.logs) > self._max_log_lines:
+            self.logs = self.logs[-self._max_log_lines :]
+
+    def task(
+        self,
+        *,
+        desc: str = "",
+        total: Optional[int] = None,
+        unit: str = "",
+    ) -> AbstractContextManager[ProgressHandle]:
+        """Create a context manager bridging pipeline progress to Gradio."""
+
+        return _GradioProgressHandle(self, desc=desc, total=total, unit=unit)
+
+    # Internal helpers -------------------------------------------------
+
+    def _start_task(self, desc: str, total: Optional[int]) -> None:
+        self._active_desc = desc or "Processing"
+        self._update_progress(0, total, self._active_desc)
+
+    def _update_progress(
+        self, current: int, total: Optional[int], desc: Optional[str]
+    ) -> None:
+        if self._progress_callback is None:
+            return
+        if total is None or total <= 0:
+            total_value = max(1, int(current) + 1 if current >= 0 else 1)
+            bounded_current = max(0, int(current))
+        else:
+            total_value = max(int(total), 1, int(current))
+            bounded_current = max(0, min(int(current), int(total_value)))
+        display_desc = desc or self._active_desc
+        self._progress_callback(bounded_current, total_value, display_desc)
+
+
+_WORKSPACES: list[Path] = []
+
+
+def _allocate_workspace() -> Path:
+    """Create and remember a workspace directory for a single request."""
+
+    path = Path(tempfile.mkdtemp(prefix="talks_reducer_web_"))
+    _WORKSPACES.append(path)
+    return path
+
+
+def _cleanup_workspaces() -> None:
+    """Remove any workspaces that remain when the process exits."""
+
+    for workspace in _WORKSPACES:
+        if workspace.exists():
+            with suppress(Exception):
+                shutil.rmtree(workspace)
+    _WORKSPACES.clear()
+
+
+def _build_output_path(input_path: Path, workspace: Path, small: bool) -> Path:
+    """Mirror the CLI output naming scheme inside the workspace directory."""
+
+    suffix = input_path.suffix or ".mp4"
+    stem = input_path.stem
+    marker = "_speedup_small" if small else "_speedup"
+    return workspace / f"{stem}{marker}{suffix}"
+
+
+def _format_duration(seconds: float) -> str:
+    """Return a compact human-readable duration string."""
+
+    if seconds <= 0:
+        return "0s"
+    total_seconds = int(round(seconds))
+    hours, remainder = divmod(total_seconds, 3600)
+    minutes, secs = divmod(remainder, 60)
+    parts: list[str] = []
+    if hours:
+        parts.append(f"{hours}h")
+    if minutes or hours:
+        parts.append(f"{minutes}m")
+    parts.append(f"{secs}s")
+    return " ".join(parts)
+
+
+def _format_summary(result: ProcessingResult) -> str:
+    """Produce a Markdown summary of the processing result."""
+
+    lines = [
+        f"**Input:** `{result.input_file.name}`",
+        f"**Output:** `{result.output_file.name}`",
+    ]
+
+    duration_line = (
+        f"**Duration:** {_format_duration(result.output_duration)}"
+        f" ({_format_duration(result.original_duration)} original)"
+    )
+    if result.time_ratio is not None:
+        duration_line += f" — {result.time_ratio * 100:.1f}% of the original"
+    lines.append(duration_line)
+
+    if result.size_ratio is not None:
+        size_percent = result.size_ratio * 100
+        lines.append(f"**Size:** {size_percent:.1f}% of the original file")
+
+    lines.append(f"**Chunks merged:** {result.chunk_count}")
+    lines.append(f"**Encoder:** {'CUDA' if result.used_cuda else 'CPU'}")
+
+    return "\n".join(lines)
+
+
+def process_video(
+    file_path: Optional[str],
+    small_video: bool,
+    progress: Optional[gr.Progress] = gr.Progress(track_tqdm=False),
+) -> tuple[Optional[str], str, str, Optional[str]]:
+    """Run the Talks Reducer pipeline for a single uploaded file."""
+
+    if not file_path:
+        raise gr.Error("Please upload a video file to begin processing.")
+
+    input_path = Path(file_path)
+    if not input_path.exists():
+        raise gr.Error("The uploaded file is no longer available on the server.")
+
+    workspace = _allocate_workspace()
+    temp_folder = workspace / "temp"
+    output_file = _build_output_path(input_path, workspace, small_video)
+
+    progress_callback: Optional[Callable[[int, int, str], None]] = None
+    if progress is not None:
+
+        def _callback(current: int, total: int, desc: str) -> None:
+            progress(current, total=total, desc=desc)
+
+        progress_callback = _callback
+
+    reporter = GradioProgressReporter(progress_callback=progress_callback)
+
+    options = ProcessingOptions(
+        input_file=input_path,
+        output_file=output_file,
+        temp_folder=temp_folder,
+        small=small_video,
+    )
+
+    try:
+        result = speed_up_video(options, reporter=reporter)
+    except FFmpegNotFoundError as exc:  # pragma: no cover - depends on runtime env
+        raise gr.Error(str(exc)) from exc
+    except FileNotFoundError as exc:
+        raise gr.Error(str(exc)) from exc
+    except Exception as exc:  # pragma: no cover - defensive fallback
+        reporter.log(f"Error: {exc}")
+        raise gr.Error(f"Failed to process the video: {exc}") from exc
+
+    reporter.log("Processing complete.")
+    log_text = "\n".join(reporter.logs)
+    summary = _format_summary(result)
+
+    return (
+        str(result.output_file),
+        log_text,
+        summary,
+        str(result.output_file),
+    )
+
+
+def build_interface() -> gr.Blocks:
+    """Construct the Gradio Blocks application for the simple web UI."""
+
+    with gr.Blocks(title="Talks Reducer Web UI") as demo:
+        gr.Markdown(
+            """
+            ## Talks Reducer — Simple Server
+            Drop a video into the zone below or click to browse. Toggle **Small video** to
+            apply the 720p/128k preset before processing starts.
+            """.strip()
+        )
+
+        with gr.Row():
+            file_input = gr.File(
+                label="Video file",
+                file_types=["video"],
+                type="filepath",
+            )
+            small_checkbox = gr.Checkbox(label="Small video", value=False)
+
+        video_output = gr.Video(label="Processed video")
+        summary_output = gr.Markdown()
+        download_output = gr.File(label="Download processed file", interactive=False)
+        log_output = gr.Textbox(label="Log", lines=12, interactive=False)
+
+        file_input.upload(
+            process_video,
+            inputs=[file_input, small_checkbox],
+            outputs=[video_output, log_output, summary_output, download_output],
+            queue=True,
+        )
+
+    demo.queue(default_concurrency_limit=1)
+    return demo
+
+
+def main(argv: Optional[Sequence[str]] = None) -> None:
+    """Launch the Gradio server from the command line."""
+
+    parser = argparse.ArgumentParser(description="Launch the Talks Reducer web UI.")
+    parser.add_argument(
+        "--host", dest="host", default=None, help="Custom host to bind."
+    )
+    parser.add_argument(
+        "--port",
+        dest="port",
+        type=int,
+        default=9005,
+        help="Port number for the web server (default: 9005).",
+    )
+    parser.add_argument(
+        "--share",
+        action="store_true",
+        help="Create a temporary public Gradio link.",
+    )
+    parser.add_argument(
+        "--no-browser",
+        action="store_true",
+        help="Do not automatically open the browser window.",
+    )
+
+    args = parser.parse_args(argv)
+
+    demo = build_interface()
+    demo.launch(
+        server_name=args.host,
+        server_port=args.port,
+        share=args.share,
+        inbrowser=not args.no_browser,
+    )
+
+
+atexit.register(_cleanup_workspaces)
+
+
+__all__ = [
+    "GradioProgressReporter",
+    "build_interface",
+    "main",
+    "process_video",
+]
+
+
+if __name__ == "__main__":  # pragma: no cover - convenience entry point
+    main()

{talks_reducer-0.4.0.dist-info → talks_reducer-0.5.0.dist-info}/METADATA

@@ -1,71 +1,93 @@
-Metadata-Version: 2.4
-Name: talks-reducer
-Version: 0.4.0
-Summary: CLI for speeding up long-form talks by removing silence
-Author: Talks Reducer Maintainers
-License-Expression: MIT
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: audiotsm>=0.1.2
-Requires-Dist: scipy>=1.10.0
-Requires-Dist: numpy>=1.22.0
-Requires-Dist: tqdm>=4.65.0
-Requires-Dist: tkinterdnd2>=0.3.0
-Requires-Dist: Pillow>=9.0.0
-Requires-Dist: imageio-ffmpeg>=0.4.8
-Provides-Extra: dev
-Requires-Dist: build>=1.0.0; extra == "dev"
-Requires-Dist: twine>=4.0.0; extra == "dev"
-Requires-Dist: pytest>=7.0.0; extra == "dev"
-Requires-Dist: black>=23.0.0; extra == "dev"
-Requires-Dist: isort>=5.12.0; extra == "dev"
-Requires-Dist: bump-my-version>=0.5.0; extra == "dev"
-Requires-Dist: pyinstaller==6.4.0; extra == "dev"
-Dynamic: license-file
-
-# Talks Reducer
-Talks Reducer shortens long-form presentations by removing silent gaps and optionally re-encoding them to smaller files. The
-project was renamed from **jumpcutter** to emphasize its focus on conference talks and screencasts.
-
-![Main demo](docs/assets/screencast-main.gif)
-
-## Example
-- 1h 37m, 571 MB — Original OBS video recording
-- 1h 19m, 751 MB — Talks Reducer
-- 1h 19m, 171 MB — Talks Reducer `--small`
-
-## Changelog
-
-See [CHANGELOG.md](CHANGELOG.md).
-
-## Install GUI (Windows, macOS)
-Go to the [releases page](https://github.com/popstas/talks-reducer/releases) and download the appropriate artifact:
-
-- **Windows** — `talks-reducer-windows.zip`
-- **macOS** — `talks-reducer.app.zip` (but it doesn't work for me)
-
-## Install CLI (Linux, Windows, macOS)
-```
-pip install talks-reducer
-```
-
-**Note:** FFmpeg is now bundled automatically with the package, so you don't need to install it separately. You you need, don't know actually.
-
-The `--small` preset applies a 720p video scale and 128 kbps audio bitrate, making it useful for sharing talks over constrained
-connections. Without `--small`, the script aims to preserve original quality while removing silence.
-
-Example CLI usage:
-
-```sh
-talks-reducer --small input.mp4
-```
-
-When CUDA-capable hardware is available the pipeline leans on GPU encoders to keep export times low, but it still runs great on
-CPUs.
-
-## Contributing
-See `CONTRIBUTION.md` for development setup details and guidance on sharing improvements.
-
-## License
-Talks Reducer is released under the MIT License. See `LICENSE` for the full text.
+Metadata-Version: 2.4
+Name: talks-reducer
+Version: 0.5.0
+Summary: CLI for speeding up long-form talks by removing silence
+Author: Talks Reducer Maintainers
+License-Expression: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: audiotsm>=0.1.2
+Requires-Dist: scipy>=1.10.0
+Requires-Dist: numpy>=1.22.0
+Requires-Dist: tqdm>=4.65.0
+Requires-Dist: tkinterdnd2>=0.3.0
+Requires-Dist: Pillow>=9.0.0
+Requires-Dist: imageio-ffmpeg>=0.4.8
+Requires-Dist: gradio>=4.0.0
+Provides-Extra: dev
+Requires-Dist: build>=1.0.0; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.12.0; extra == "dev"
+Requires-Dist: bump-my-version>=0.5.0; extra == "dev"
+Requires-Dist: pyinstaller>=6.4.0; extra == "dev"
+Dynamic: license-file
+
+# Talks Reducer
+Talks Reducer shortens long-form presentations by removing silent gaps and optionally re-encoding them to smaller files. The
+project was renamed from **jumpcutter** to emphasize its focus on conference talks and screencasts.
+
+![Main demo](docs/assets/screencast-main.gif)
+
+## Example
+- 1h 37m, 571 MB — Original OBS video recording
+- 1h 19m, 751 MB — Talks Reducer
+- 1h 19m, 171 MB — Talks Reducer `--small`
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md).
+
+## Install GUI (Windows, macOS)
+Go to the [releases page](https://github.com/popstas/talks-reducer/releases) and download the appropriate artifact:
+
+- **Windows** — `talks-reducer-windows-0.4.0.zip`
+- **macOS** — `talks-reducer.app.zip` (but it doesn't work for me)
+
+When extracted on Windows the bundled `talks-reducer.exe` behaves like the
+`python talks_reducer/gui.py` entry point: double-clicking it launches the GUI
+and passing a video file path (for example via *Open with…* or drag-and-drop
+onto the executable) automatically queues that recording for processing.
+
+## Install CLI (Linux, Windows, macOS)
+```
+pip install talks-reducer
+```
+
+**Note:** FFmpeg is now bundled automatically with the package, so you don't need to install it separately. You you need, don't know actually.
+
+The `--small` preset applies a 720p video scale and 128 kbps audio bitrate, making it useful for sharing talks over constrained
+connections. Without `--small`, the script aims to preserve original quality while removing silence.
+
+Example CLI usage:
+
+```sh
+talks-reducer --small input.mp4
+```
+
+### Speech detection
+
+Talks Reducer now relies on its built-in volume thresholding to detect speech. Adjust `--silent_threshold` if you need to fine-tune when segments count as silence. Dropping the optional Silero VAD integration keeps the install lightweight and avoids pulling in PyTorch.
+
+When CUDA-capable hardware is available the pipeline leans on GPU encoders to keep export times low, but it still runs great on
+CPUs.
+
+## Simple web server
+
+Prefer a lightweight browser interface? Launch the Gradio-powered simple mode with:
+
+```sh
+talks-reducer server
+```
+
+This opens a local web page featuring a drag-and-drop upload zone, a **Small video** checkbox that mirrors the CLI preset, a live
+progress indicator, and automatic previews of the processed output. Once the job completes you can inspect the resulting compression
+ratio and download the rendered video directly from the page.
+
+## Contributing
+See `CONTRIBUTION.md` for development setup details and guidance on sharing improvements.
+
+## License
+Talks Reducer is released under the MIT License. See `LICENSE` for the full text.

talks_reducer-0.5.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+talks_reducer/__about__.py,sha256=RhSau8kONixzPMrozb3d8HJbGwsQmAY3l5_HbL3elh4,92
+talks_reducer/__init__.py,sha256=Kzh1hXaw6Vq3DyTqrnJGOq8pn0P8lvaDcsg1bFUjFKk,208
+talks_reducer/__main__.py,sha256=azR_vh8HFPLaOnh-L6gUFWsL67I6iHtbeH5rQhsipGY,299
+talks_reducer/audio.py,sha256=sjHMeY0H9ESG-Gn5BX0wFRBX7sXjWwsgS8u9Vb0bJ88,4396
+talks_reducer/chunks.py,sha256=IpdZxRFPURSG5wP-OQ_p09CVP8wcKwIFysV29zOTSWI,2959
+talks_reducer/cli.py,sha256=9Lj47GTtvr1feYBrNtQ2aB3r4sLquLODMZk_K_YAIEk,7990
+talks_reducer/ffmpeg.py,sha256=Joqtkq-bktP-Hq3j3I394FYB_VQ-7GyF0n7bqTiknrg,12356
+talks_reducer/gui.py,sha256=6OTUfIMH30XBOFq-BYZmxnODp0HhW3oj7CcTqLdpKyI,59739
+talks_reducer/models.py,sha256=Ax7OIV7WECRROi5km-Se0Z1LQsLxd5J7GnGXDbWrNjg,1197
+talks_reducer/pipeline.py,sha256=kemU_Txoh38jLzJCjy0HvjUS1gtvmVItnxXhlZcdw5Y,12195
+talks_reducer/progress.py,sha256=Mh43M6VWhjjUv9CI22xfD2EJ_7Aq3PCueqefQ9Bd5-o,4565
+talks_reducer/server.py,sha256=r5P7fGfU9SGxwPYDaSsSnEllzwjlombOJ-FF8B5iAZQ,11128
+talks_reducer-0.5.0.dist-info/licenses/LICENSE,sha256=jN17mHNR3e84awmH3AbpWBcBDBzPxEH0rcOFoj1s7sQ,1124
+talks_reducer-0.5.0.dist-info/METADATA,sha256=Rrw6kiDxbQT7q6I0QnbWcNxsJsMLLe0z145f4Zr9kBM,3636
+talks_reducer-0.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+talks_reducer-0.5.0.dist-info/entry_points.txt,sha256=no-NVP5Z9LrzaJL4-2ltKe9IkLZo8dQ32zilIb1gbZE,149
+talks_reducer-0.5.0.dist-info/top_level.txt,sha256=pJWGcy__LR9JIEKH3QJyFmk9XrIsiFtqvuMNxFdIzDU,14
+talks_reducer-0.5.0.dist-info/RECORD,,

{talks_reducer-0.4.0.dist-info → talks_reducer-0.5.0.dist-info}/entry_points.txt

@@ -1,3 +1,4 @@
 [console_scripts]
 talks-reducer = talks_reducer.cli:main
 talks-reducer-gui = talks_reducer.gui:main
+talks-reducer-server = talks_reducer.server:main

talks_reducer-0.4.0.dist-info/RECORD

@@ -1,17 +0,0 @@
-talks_reducer/__about__.py,sha256=2XVXbkR7SSSCzPemYAwJFimV_pxTmx61hlVaLn82ERk,92
-talks_reducer/__init__.py,sha256=Kzh1hXaw6Vq3DyTqrnJGOq8pn0P8lvaDcsg1bFUjFKk,208
-talks_reducer/__main__.py,sha256=azR_vh8HFPLaOnh-L6gUFWsL67I6iHtbeH5rQhsipGY,299
-talks_reducer/audio.py,sha256=sjHMeY0H9ESG-Gn5BX0wFRBX7sXjWwsgS8u9Vb0bJ88,4396
-talks_reducer/chunks.py,sha256=IpdZxRFPURSG5wP-OQ_p09CVP8wcKwIFysV29zOTSWI,2959
-talks_reducer/cli.py,sha256=OYmahiEo7ivhix4861pN9Kp1DkRvU7WBj6fBE2cVVWU,7377
-talks_reducer/ffmpeg.py,sha256=CVrxwNcWHrzvxTzoALtx5UdNWXxxfOFYF3FES7lvaO4,11680
-talks_reducer/gui.py,sha256=xsJj1uO1WX14rNVSrkQf2b4K6BdNDbeZ-A1bB0fsSIM,54463
-talks_reducer/models.py,sha256=vdQLliiHKUuYtNlZzS796kGK39cbtjkUfYcT95KwwKE,1197
-talks_reducer/pipeline.py,sha256=nfAX8dooN3-009WqMyYTv4nINNMtVmbWtsmzQeBM9Wg,9415
-talks_reducer/progress.py,sha256=Mh43M6VWhjjUv9CI22xfD2EJ_7Aq3PCueqefQ9Bd5-o,4565
-talks_reducer-0.4.0.dist-info/licenses/LICENSE,sha256=jN17mHNR3e84awmH3AbpWBcBDBzPxEH0rcOFoj1s7sQ,1124
-talks_reducer-0.4.0.dist-info/METADATA,sha256=nPW6e70RrF2FrVpUnF7L0CE02_UNuvurigmiAQqW5kg,2443
-talks_reducer-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-talks_reducer-0.4.0.dist-info/entry_points.txt,sha256=LCzfSnh_7VXhvl9twoFSAj0C3sG7bayWs2LkxpH7hoI,100
-talks_reducer-0.4.0.dist-info/top_level.txt,sha256=pJWGcy__LR9JIEKH3QJyFmk9XrIsiFtqvuMNxFdIzDU,14
-talks_reducer-0.4.0.dist-info/RECORD,,