talks-reducer 0.2.24__tar.gz → 0.3.0__tar.gz

{talks_reducer-0.2.24/talks_reducer.egg-info → talks_reducer-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: talks-reducer
-Version: 0.2.24
+Version: 0.3.0
 Summary: CLI for speeding up long-form talks by removing silence
 Author: Talks Reducer Maintainers
 License-Expression: MIT
@@ -85,6 +85,8 @@ continues to work unchanged for local development.
 - **Input drop zone** — drag files or folders from your desktop or add them via
   the Explorer/Finder dialog; duplicates are ignored.
 - **Small video** — toggles the `--small` preset used by the CLI.
+- **Open after convert** — controls whether the exported file is revealed in
+  your system file manager as soon as each job finishes.
 - **Advanced** — reveals optional controls for the output path, temp folder,
   timing/audio knobs mirrored from the command line, and an appearance picker
   that can force dark or light mode or follow your operating system.
@@ -94,6 +96,10 @@ a background thread. Once every queued job succeeds an **Open last output**
 button appears so you can jump straight to the exported file in your system
 file manager.
 
+The GUI stores your last-used Simple mode, Small video, Open after convert, and
+theme preferences in a cross-platform configuration file so they persist across
+launches.
+
 ## Repository Structure
 - `talks_reducer/` — Python package that exposes the CLI and reusable pipeline:
   - `cli.py` parses arguments and dispatches to the pipeline.

{talks_reducer-0.2.24 → talks_reducer-0.3.0}/README.md

@@ -60,6 +60,8 @@ continues to work unchanged for local development.
 - **Input drop zone** — drag files or folders from your desktop or add them via
   the Explorer/Finder dialog; duplicates are ignored.
 - **Small video** — toggles the `--small` preset used by the CLI.
+- **Open after convert** — controls whether the exported file is revealed in
+  your system file manager as soon as each job finishes.
 - **Advanced** — reveals optional controls for the output path, temp folder,
   timing/audio knobs mirrored from the command line, and an appearance picker
   that can force dark or light mode or follow your operating system.
@@ -69,6 +71,10 @@ a background thread. Once every queued job succeeds an **Open last output**
 button appears so you can jump straight to the exported file in your system
 file manager.
 
+The GUI stores your last-used Simple mode, Small video, Open after convert, and
+theme preferences in a cross-platform configuration file so they persist across
+launches.
+
 ## Repository Structure
 - `talks_reducer/` — Python package that exposes the CLI and reusable pipeline:
   - `cli.py` parses arguments and dispatches to the pipeline.

{talks_reducer-0.2.24 → talks_reducer-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "talks-reducer"
-version = "0.2.24"
+version = "0.3.0"
 description = "CLI for speeding up long-form talks by removing silence"
 readme = "README.md"
 requires-python = ">=3.9"

{talks_reducer-0.2.24 → talks_reducer-0.3.0}/talks_reducer/ffmpeg.py

@@ -190,8 +190,13 @@ def run_timed_ffmpeg_command(
     desc: str = "",
     total: Optional[int] = None,
     unit: str = "frames",
+    process_callback: Optional[callable] = None,
 ) -> None:
-    """Execute an FFmpeg command while streaming progress information."""
+    """Execute an FFmpeg command while streaming progress information.
+    
+    Args:
+        process_callback: Optional callback that receives the subprocess.Popen object
+    """
 
     import shlex
 
@@ -221,6 +226,10 @@ def run_timed_ffmpeg_command(
         print(f"Error starting FFmpeg: {exc}", file=sys.stderr)
         raise
 
+    # Notify callback with process object
+    if process_callback:
+        process_callback(process)
+
     progress_reporter = reporter or TqdmProgressReporter()
     task_manager = progress_reporter.task(desc=desc, total=total, unit=unit)
     with task_manager as progress:
@@ -234,6 +243,9 @@ def run_timed_ffmpeg_command(
 
             sys.stderr.write(line)
             sys.stderr.flush()
+            
+            # Send FFmpeg output to reporter for GUI display
+            progress_reporter.log(line.strip())
 
             match = re.search(r"frame=\s*(\d+)", line)
             if match:

{talks_reducer-0.2.24 → talks_reducer-0.3.0}/talks_reducer/gui.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import json
 import os
+import re
 import subprocess
 import sys
 import threading
@@ -117,9 +118,10 @@ except ModuleNotFoundError:  # pragma: no cover - runtime dependency
 
 STATUS_COLORS = {
     "idle": "#9ca3af",
-    "processing": "#facc15",
-    "success": "#22c55e",
-    "error": "#f87171",
+    "processing": "#af8e0e",
+    "success": "#178941",
+    "error": "#ad4f4f",
+    "aborted": "#6d727a",
 }
 
 LIGHT_THEME = {
@@ -128,7 +130,8 @@ LIGHT_THEME = {
     "accent": "#2563eb",
     "surface": "#ffffff",
     "border": "#cbd5e1",
-    "hover": "#1d4ed8",
+    "hover": "#efefef",
+    "hover_text": "#000000",
     "selection_background": "#2563eb",
     "selection_foreground": "#ffffff",
 }
@@ -140,6 +143,7 @@ DARK_THEME = {
     "surface": "#2b2b3c",
     "border": "#4b5563",
     "hover": "#333333",
+    "hover_text": "#ffffff",
     "selection_background": "#333333",
     "selection_foreground": "#f3f4f6",
 }
@@ -186,8 +190,13 @@ class _GuiProgressHandle(ProgressHandle):
 class _TkProgressReporter(SignalProgressReporter):
     """Progress reporter that forwards updates to the GUI thread."""
 
-    def __init__(self, log_callback: Callable[[str], None]) -> None:
+    def __init__(
+        self,
+        log_callback: Callable[[str], None],
+        process_callback: Optional[Callable] = None,
+    ) -> None:
         self._log_callback = log_callback
+        self.process_callback = process_callback
 
     def log(self, message: str) -> None:
         self._log_callback(message)
@@ -202,7 +211,55 @@ class _TkProgressReporter(SignalProgressReporter):
 class TalksReducerGUI:
     """Tkinter application mirroring the CLI options with form controls."""
 
+    PADDING = 10
+
+    def _determine_config_path(self) -> Path:
+        if sys.platform == "win32":
+            appdata = os.environ.get("APPDATA")
+            base = Path(appdata) if appdata else Path.home() / "AppData" / "Roaming"
+        elif sys.platform == "darwin":
+            base = Path.home() / "Library" / "Application Support"
+        else:
+            xdg_config = os.environ.get("XDG_CONFIG_HOME")
+            base = Path(xdg_config) if xdg_config else Path.home() / ".config"
+        return base / "talks-reducer" / "settings.json"
+
+    def _load_settings(self) -> dict[str, object]:
+        try:
+            with self._config_path.open("r", encoding="utf-8") as handle:
+                data = json.load(handle)
+            if isinstance(data, dict):
+                return data
+        except FileNotFoundError:
+            return {}
+        except (OSError, json.JSONDecodeError):
+            return {}
+        return {}
+
+    def _save_settings(self) -> None:
+        try:
+            self._config_path.parent.mkdir(parents=True, exist_ok=True)
+            with self._config_path.open("w", encoding="utf-8") as handle:
+                json.dump(self._settings, handle, indent=2, sort_keys=True)
+        except OSError:
+            pass
+
+    def _get_setting(self, key: str, default: object) -> object:
+        value = self._settings.get(key, default)
+        if key not in self._settings:
+            self._settings[key] = value
+        return value
+
+    def _update_setting(self, key: str, value: object) -> None:
+        if self._settings.get(key) == value:
+            return
+        self._settings[key] = value
+        self._save_settings()
+
     def __init__(self) -> None:
+        self._config_path = self._determine_config_path()
+        self._settings = self._load_settings()
+
         # Import tkinter here to avoid loading it at module import time
         import tkinter as tk
         from tkinter import filedialog, messagebox, ttk
@@ -217,18 +274,18 @@ class TalksReducerGUI:
             self.root = TkinterDnD.Tk()  # type: ignore[call-arg]
         else:
             self.root = tk.Tk()
-        
+
         # Set window title with version
         try:
             app_version = version("talks-reducer")
             self.root.title(f"Talks Reducer v{app_version}")
         except Exception:
             self.root.title("Talks Reducer")
-        
+
         self._apply_window_icon()
 
         self._full_size = (760, 680)
-        self._simple_size = (255, 300)
+        self._simple_size = (255, 330)
         self.root.geometry(f"{self._full_size[0]}x{self._full_size[1]}")
         self.style = self.ttk.Style(self.root)
 
@@ -238,21 +295,36 @@ class TalksReducerGUI:
         self.status_var = tk.StringVar(value=self._status_state)
         self._status_animation_job: Optional[str] = None
         self._status_animation_phase = 0
+        self._video_duration_seconds: Optional[float] = None
+        self.progress_var = tk.IntVar(value=0)
+        self._ffmpeg_process: Optional[subprocess.Popen] = None
+        self._stop_requested = False
 
         self.input_files: List[str] = []
 
         self._dnd_available = TkinterDnD is not None and DND_FILES is not None
 
-        self.simple_mode_var = tk.BooleanVar(value=True)
+        self.simple_mode_var = tk.BooleanVar(
+            value=self._get_setting("simple_mode", True)
+        )
         self.run_after_drop_var = tk.BooleanVar(value=True)
-        self.small_var = tk.BooleanVar(value=True)
-        self.theme_var = tk.StringVar(value="os")
+        self.small_var = tk.BooleanVar(value=self._get_setting("small_video", True))
+        self.open_after_convert_var = tk.BooleanVar(
+            value=self._get_setting("open_after_convert", True)
+        )
+        self.theme_var = tk.StringVar(value=self._get_setting("theme", "os"))
         self.theme_var.trace_add("write", self._on_theme_change)
+        self.small_var.trace_add("write", self._on_small_video_change)
+        self.open_after_convert_var.trace_add(
+            "write", self._on_open_after_convert_change
+        )
 
         self._build_layout()
         self._apply_simple_mode(initial=True)
         self._apply_status_style(self._status_state)
         self._apply_theme()
+        self._save_settings()
+        self._hide_stop_button()
 
         if not self._dnd_available:
             self._append_log(
@@ -289,16 +361,17 @@ class TalksReducerGUI:
                 continue
 
     def _build_layout(self) -> None:
-        main = self.ttk.Frame(self.root, padding=16)
+        main = self.ttk.Frame(self.root, padding=self.PADDING)
         main.grid(row=0, column=0, sticky="nsew")
         self.root.columnconfigure(0, weight=1)
         self.root.rowconfigure(0, weight=1)
 
         # Input selection frame
-        input_frame = self.ttk.LabelFrame(main, text="Input files", padding=12)
+        input_frame = self.ttk.Frame(main, padding=self.PADDING)
         input_frame.grid(row=0, column=0, sticky="nsew")
         main.rowconfigure(0, weight=1)
-        for column in range(4):
+        main.columnconfigure(0, weight=1)
+        for column in range(5):
             input_frame.columnconfigure(column, weight=1)
 
         self.input_list = self.tk.Listbox(input_frame, height=5)
@@ -312,13 +385,13 @@ class TalksReducerGUI:
         self.drop_zone = self.tk.Label(
             input_frame,
             text="Drop files or folders here",
-            relief=self.tk.RIDGE,
-            borderwidth=2,
-            padx=16,
-            pady=16,
-            highlightthickness=1,
+            relief=self.tk.FLAT,
+            borderwidth=0,
+            padx=self.PADDING,
+            pady=self.PADDING,
+            highlightthickness=0,
         )
-        self.drop_zone.grid(row=1, column=0, columnspan=4, sticky="nsew")
+        self.drop_zone.grid(row=1, column=0, columnspan=5, sticky="nsew")
         input_frame.rowconfigure(1, weight=1)
         self._configure_drop_targets(self.drop_zone)
         self._configure_drop_targets(self.input_list)
@@ -343,8 +416,8 @@ class TalksReducerGUI:
         self.run_after_drop_check.grid(row=2, column=3, pady=8, sticky="e")
 
         # Options frame
-        options = self.ttk.LabelFrame(main, text="Options", padding=12)
-        options.grid(row=1, column=0, pady=(16, 0), sticky="nsew")
+        options = self.ttk.Frame(main, padding=self.PADDING)
+        options.grid(row=2, column=0, pady=(16, 0), sticky="ew")
         options.columnconfigure(0, weight=1)
 
         self.simple_mode_check = self.ttk.Checkbutton(
@@ -359,6 +432,12 @@ class TalksReducerGUI:
             row=1, column=0, sticky="w", pady=(8, 0)
         )
 
+        self.ttk.Checkbutton(
+            options,
+            text="Open after convert",
+            variable=self.open_after_convert_var,
+        ).grid(row=2, column=0, sticky="w", pady=(8, 0))
+
         self.advanced_visible = self.tk.BooleanVar(value=False)
         self.advanced_button = self.ttk.Button(
             options,
@@ -367,8 +446,8 @@ class TalksReducerGUI:
         )
         self.advanced_button.grid(row=0, column=1, sticky="e")
 
-        self.advanced_frame = self.ttk.Frame(options, padding=(0, 12, 0, 0))
-        self.advanced_frame.grid(row=2, column=0, columnspan=2, sticky="nsew")
+        self.advanced_frame = self.ttk.Frame(options, padding=self.PADDING)
+        self.advanced_frame.grid(row=3, column=0, columnspan=2, sticky="nsew")
         self.advanced_frame.columnconfigure(1, weight=1)
 
         self.output_var = self.tk.StringVar()
@@ -424,33 +503,54 @@ class TalksReducerGUI:
         self._toggle_advanced(initial=True)
 
         # Action buttons and log output
-        self.actions_frame = self.ttk.Frame(main)
-        self.actions_frame.grid(row=2, column=0, pady=(16, 0), sticky="ew")
-        self.actions_frame.columnconfigure(1, weight=1)
+        status_frame = self.ttk.Frame(main, padding=self.PADDING)
+        status_frame.grid(row=1, column=0, sticky="ew")
+        status_frame.columnconfigure(0, weight=0)
+        status_frame.columnconfigure(1, weight=1)
+        status_frame.columnconfigure(2, weight=0)
+
+        
+        self.ttk.Label(status_frame, text="Status:").grid(row=0, column=0, sticky="w")
+        self.status_label = self.tk.Label(status_frame, textvariable=self.status_var, anchor="e")
+        self.status_label.grid(row=0, column=1, sticky="e")
+
+        # Progress bar
+        self.progress_bar = self.ttk.Progressbar(
+            status_frame,
+            variable=self.progress_var,
+            maximum=100,
+            mode="determinate",
+            style="Idle.Horizontal.TProgressbar",
+        )
+        self.progress_bar.grid(row=1, column=0, columnspan=3, sticky="ew", pady=(0, 0))
 
-        self.run_button = self.ttk.Button(
-            self.actions_frame, text="Run", command=self._start_run
+        self.stop_button = self.ttk.Button(
+            status_frame, text="Stop", command=self._stop_processing
         )
-        self.run_button.grid(row=0, column=0, sticky="w")
+        self.stop_button.grid(row=2, column=0, columnspan=3, sticky="ew", pady=self.PADDING)
+        self.stop_button.grid_remove()  # Hidden by default
 
         self.open_button = self.ttk.Button(
-            self.actions_frame,
-            text="Open last output",
+            status_frame,
+            text="Open last",
             command=self._open_last_output,
             state=self.tk.DISABLED,
         )
-        self.open_button.grid(row=0, column=1, sticky="e")
+        self.open_button.grid(row=2, column=0, columnspan=3, sticky="ew", pady=self.PADDING)
         self.open_button.grid_remove()
 
-        status_frame = self.ttk.Frame(main, padding=(0, 8, 0, 0))
-        status_frame.grid(row=3, column=0, sticky="ew")
-        status_frame.columnconfigure(1, weight=1)
-        self.ttk.Label(status_frame, text="Status:").grid(row=0, column=0, sticky="w")
-        self.status_label = self.tk.Label(status_frame, textvariable=self.status_var)
-        self.status_label.grid(row=0, column=1, sticky="w")
+        # Button shown when no other action buttons are visible
+        self.drop_hint_button = self.ttk.Button(
+            status_frame,
+            text="Drop video to convert",
+            state=self.tk.DISABLED,
+        )
+        self.drop_hint_button.grid(row=2, column=0, columnspan=3, sticky="ew", pady=self.PADDING)
+        self.drop_hint_button.grid_remove()  # Hidden by default
+        self._configure_drop_targets(self.drop_hint_button)
 
-        self.log_frame = self.ttk.LabelFrame(main, text="Log", padding=12)
-        self.log_frame.grid(row=4, column=0, pady=(16, 0), sticky="nsew")
+        self.log_frame = self.ttk.Frame(main, padding=self.PADDING)
+        self.log_frame.grid(row=3, column=0, pady=(16, 0), sticky="nsew")
         main.rowconfigure(4, weight=1)
         self.log_frame.columnconfigure(0, weight=1)
         self.log_frame.rowconfigure(0, weight=1)
@@ -486,6 +586,7 @@ class TalksReducerGUI:
             button.grid(row=row, column=2, padx=(8, 0))
 
     def _toggle_simple_mode(self) -> None:
+        self._update_setting("simple_mode", self.simple_mode_var.get())
         self._apply_simple_mode()
 
     def _apply_simple_mode(self, *, initial: bool = False) -> None:
@@ -503,21 +604,23 @@ class TalksReducerGUI:
             for widget in widgets:
                 widget.grid_remove()
             self.log_frame.grid_remove()
-            self.run_button.grid_remove()
+            self.stop_button.grid_remove()
             self.advanced_button.grid_remove()
             self.advanced_frame.grid_remove()
-            self.actions_frame.grid_remove()
+            if hasattr(self, 'status_frame'):
+                self.status_frame.grid_remove()
             self.run_after_drop_var.set(True)
             self._apply_window_size(simple=True)
-            if self.status_var.get().lower() == "success":
-                self.actions_frame.grid()
+            if self.status_var.get().lower() == "success" and hasattr(self, 'status_frame'):
+                self.status_frame.grid()
                 self.open_button.grid()
+                self.drop_hint_button.grid_remove()
         else:
             for widget in widgets:
                 widget.grid()
             self.log_frame.grid()
-            self.actions_frame.grid()
-            self.run_button.grid()
+            if hasattr(self, 'status_frame'):
+                self.status_frame.grid()
             self.advanced_button.grid()
             if self.advanced_visible.get():
                 self.advanced_frame.grid()
@@ -551,8 +654,17 @@ class TalksReducerGUI:
             self.advanced_button.configure(text="Advanced")
 
     def _on_theme_change(self, *_: object) -> None:
+        self._update_setting("theme", self.theme_var.get())
         self._apply_theme()
 
+    def _on_small_video_change(self, *_: object) -> None:
+        self._update_setting("small_video", bool(self.small_var.get()))
+
+    def _on_open_after_convert_change(self, *_: object) -> None:
+        self._update_setting(
+            "open_after_convert", bool(self.open_after_convert_var.get())
+        )
+
     def _apply_theme(self) -> None:
         preference = self.theme_var.get().lower()
         if preference not in {"light", "dark"}:
@@ -572,6 +684,8 @@ class TalksReducerGUI:
             "TLabelframe",
             background=palette["background"],
             foreground=palette["foreground"],
+            borderwidth=0,
+            relief="flat",
         )
         self.style.configure(
             "TLabelframe.Label",
@@ -586,11 +700,19 @@ class TalksReducerGUI:
             background=palette["background"],
             foreground=palette["foreground"],
         )
+        self.style.map(
+            "TCheckbutton",
+            background=[("active", palette.get("hover", palette["background"]))],
+        )
         self.style.configure(
             "TRadiobutton",
             background=palette["background"],
             foreground=palette["foreground"],
         )
+        self.style.map(
+            "TRadiobutton",
+            background=[("active", palette.get("hover", palette["background"]))],
+        )
         self.style.configure(
             "TButton",
             background=palette["surface"],
@@ -604,7 +726,7 @@ class TalksReducerGUI:
                 ("disabled", palette["surface"]),
             ],
             foreground=[
-                ("active", palette["surface"]),
+                ("active", palette.get("hover_text", "#000000")),
                 ("disabled", palette["foreground"]),
             ],
         )
@@ -619,11 +741,47 @@ class TalksReducerGUI:
             foreground=palette["foreground"],
         )
 
+        # Configure progress bar styles for different states
+        self.style.configure(
+            "Idle.Horizontal.TProgressbar",
+            background=STATUS_COLORS["idle"],
+            troughcolor=palette["surface"],
+            borderwidth=0,
+            thickness=20,
+        )
+        self.style.configure(
+            "Processing.Horizontal.TProgressbar",
+            background=STATUS_COLORS["processing"],
+            troughcolor=palette["surface"],
+            borderwidth=0,
+            thickness=20,
+        )
+        self.style.configure(
+            "Success.Horizontal.TProgressbar",
+            background=STATUS_COLORS["success"],
+            troughcolor=palette["surface"],
+            borderwidth=0,
+            thickness=20,
+        )
+        self.style.configure(
+            "Error.Horizontal.TProgressbar",
+            background=STATUS_COLORS["error"],
+            troughcolor=palette["surface"],
+            borderwidth=0,
+            thickness=20,
+        )
+        self.style.configure(
+            "Aborted.Horizontal.TProgressbar",
+            background=STATUS_COLORS["aborted"],
+            troughcolor=palette["surface"],
+            borderwidth=0,
+            thickness=20,
+        )
+
         self.drop_zone.configure(
             bg=palette["surface"],
             fg=palette["foreground"],
-            highlightbackground=palette["border"],
-            highlightcolor=palette["border"],
+            highlightthickness=0,
         )
         self.input_list.configure(
             bg=palette["surface"],
@@ -714,12 +872,20 @@ class TalksReducerGUI:
             self.input_list.delete(index)
             del self.input_files[index]
 
+    def _clear_input_files(self) -> None:
+        """Clear all input files from the list."""
+        self.input_files.clear()
+        self.input_list.delete(0, self.tk.END)
+
     def _on_drop(self, event: object) -> None:
         data = getattr(event, "data", "")
         if not data:
             return
         paths = self.root.tk.splitlist(data)
         cleaned = [path.strip("{}") for path in paths]
+        # Clear existing files before adding dropped files
+        self.input_files.clear()
+        self.input_list.delete(0, self.tk.END)
         self._extend_inputs(cleaned, auto_run=True)
 
     def _browse_path(
@@ -753,10 +919,16 @@ class TalksReducerGUI:
             return
 
         self._append_log("Starting processing…")
-        self.run_button.configure(state=self.tk.DISABLED)
+        self._stop_requested = False
+        open_after_convert = bool(self.open_after_convert_var.get())
 
         def worker() -> None:
-            reporter = _TkProgressReporter(self._append_log)
+            def set_process(proc: subprocess.Popen) -> None:
+                self._ffmpeg_process = proc
+
+            reporter = _TkProgressReporter(
+                self._append_log, process_callback=set_process
+            )
             try:
                 files = gather_input_files(self.input_files)
                 if not files:
@@ -776,30 +948,75 @@ class TalksReducerGUI:
                     result = speed_up_video(options, reporter=reporter)
                     self._last_output = result.output_file
                     self._append_log(f"Completed: {result.output_file}")
-                    self._notify(
-                        lambda path=result.output_file: self._open_in_file_manager(path)
-                    )
+                    if open_after_convert:
+                        self._notify(
+                            lambda path=result.output_file: self._open_in_file_manager(
+                                path
+                            )
+                        )
 
                 self._append_log("All jobs finished successfully.")
                 self._notify(lambda: self.open_button.configure(state=self.tk.NORMAL))
+                self._notify(self._clear_input_files)
             except FFmpegNotFoundError as exc:
                 self._notify(
                     lambda: self.messagebox.showerror("FFmpeg not found", str(exc))
                 )
                 self._set_status("Error")
             except Exception as exc:  # pragma: no cover - GUI level safeguard
-                self._notify(
-                    lambda: self.messagebox.showerror(
-                        "Error", f"Processing failed: {exc}"
+                # If stop was requested, don't show error (FFmpeg termination is expected)
+                if self._stop_requested:
+                    self._append_log("Processing aborted by user.")
+                    self._set_status("Aborted")
+                else:
+                    self._notify(
+                        lambda: self.messagebox.showerror(
+                            "Error", f"Processing failed: {exc}"
+                        )
                     )
-                )
-                self._set_status("Error")
+                    self._set_status("Error")
             finally:
-                self._notify(lambda: self.run_button.configure(state=self.tk.NORMAL))
+                self._notify(self._hide_stop_button)
 
         self._processing_thread = threading.Thread(target=worker, daemon=True)
         self._processing_thread.start()
 
+        # Show Stop button when processing starts
+        self.stop_button.grid()
+
+    def _stop_processing(self) -> None:
+        """Stop the currently running processing by terminating FFmpeg."""
+        import signal
+
+        self._stop_requested = True
+        if self._ffmpeg_process and self._ffmpeg_process.poll() is None:
+            self._append_log("Stopping FFmpeg process...")
+            try:
+                # Send SIGTERM to FFmpeg process
+                if sys.platform == "win32":
+                    # Windows doesn't have SIGTERM, use terminate()
+                    self._ffmpeg_process.terminate()
+                else:
+                    # Unix-like systems can use SIGTERM
+                    self._ffmpeg_process.send_signal(signal.SIGTERM)
+
+                self._append_log("FFmpeg process stopped.")
+            except Exception as e:
+                self._append_log(f"Error stopping process: {e}")
+        else:
+            self._append_log("No active FFmpeg process to stop.")
+
+        self._hide_stop_button()
+
+    def _hide_stop_button(self) -> None:
+        """Hide Stop button."""
+        self.stop_button.grid_remove()
+        # Show drop hint when stop button is hidden and no other buttons are visible
+        if (not self.open_button.winfo_viewable() and 
+            hasattr(self, 'drop_hint_button') and
+            not self.drop_hint_button.winfo_viewable()):
+            self.drop_hint_button.grid()
+
     def _collect_arguments(self) -> dict[str, object]:
         args: dict[str, object] = {}
 
@@ -884,17 +1101,59 @@ class TalksReducerGUI:
         normalized = message.strip().lower()
         if "all jobs finished successfully" in normalized:
             self._set_status("Success")
+            self._set_progress(100)  # 100% on success
+            self._video_duration_seconds = None  # Reset for next video
+        elif normalized.startswith("extracting audio"):
+            self._set_status("Extracting audio...")
+            self._set_progress(0)  # 0% on start
+            self._video_duration_seconds = None  # Reset for new processing
         elif normalized.startswith("starting processing") or normalized.startswith(
             "processing"
         ):
             self._set_status("Processing")
+            self._set_progress(0)  # 0% on start
+            self._video_duration_seconds = None  # Reset for new processing
+
+        # Parse video duration from FFmpeg output
+        duration_match = re.search(r"Duration:\s*(\d{2}):(\d{2}):(\d{2}\.\d+)", message)
+        if duration_match:
+            hours = int(duration_match.group(1))
+            minutes = int(duration_match.group(2))
+            seconds = float(duration_match.group(3))
+            self._video_duration_seconds = hours * 3600 + minutes * 60 + seconds
+
+        # Parse FFmpeg progress information (time and speed)
+        time_match = re.search(r"time=(\d{2}):(\d{2}):(\d{2})\.\d+", message)
+        speed_match = re.search(r"speed=\s*([\d.]+)x", message)
+
+        if time_match and speed_match:
+            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}"
+            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(f"{time_str}, {speed_str}x ({percentage}%)")
+                self._set_progress(percentage)  # Update progress bar
+            else:
+                self._set_status(f"{time_str}, {speed_str}x")
 
     def _apply_status_style(self, status: str) -> None:
         color = STATUS_COLORS.get(status.lower())
         if color:
             self.status_label.configure(fg=color)
         else:
-            self.status_label.configure(fg="")
+            # For extracting audio or FFmpeg progress messages, use processing color
+            if "extracting audio" in status.lower() or re.search(
+                r"\d{2}:\d{2}:\d{2}.*\d+\.?\d*x", status
+            ):
+                self.status_label.configure(fg=STATUS_COLORS["processing"])
 
     def _set_status(self, status: str) -> None:
         def apply() -> None:
@@ -902,22 +1161,35 @@ class TalksReducerGUI:
             self._status_state = status
             self.status_var.set(status)
             self._apply_status_style(status)
+            self._set_progress_bar_style(status)
             lowered = status.lower()
-            if lowered == "processing":
-                self.run_button.configure(state=self.tk.DISABLED)
+            is_processing = lowered == "processing" or "extracting audio" in lowered
+
+            if is_processing:
                 self._start_status_animation()
-            else:
-                if not self.simple_mode_var.get():
-                    self.run_button.configure(state=self.tk.NORMAL)
+                # Show stop button during processing
+                if hasattr(self, 'status_frame'):
+                    self.status_frame.grid()
+                self.stop_button.grid()
+                self.drop_hint_button.grid_remove()
 
             if lowered == "success":
-                if self.simple_mode_var.get():
-                    self.actions_frame.grid()
+                if self.simple_mode_var.get() and hasattr(self, 'status_frame'):
+                    self.status_frame.grid()
+                    self.stop_button.grid_remove()
+                self.drop_hint_button.grid_remove()
                 self.open_button.grid()
+                self.open_button.lift()  # Ensure open_button is above drop_hint_button
+                print("success status")
             else:
                 self.open_button.grid_remove()
-                if self.simple_mode_var.get():
-                    self.actions_frame.grid_remove()
+                print("not success status")
+                if self.simple_mode_var.get() and not is_processing and hasattr(self, 'status_frame'):
+                    self.status_frame.grid_remove()
+                    self.stop_button.grid_remove()
+                    # Show drop hint when no other buttons are visible
+                    if hasattr(self, 'drop_hint_button'):
+                        self.drop_hint_button.grid()
 
         self.root.after(0, apply)
 
@@ -945,6 +1217,99 @@ class TalksReducerGUI:
         if self._status_state.lower() != "processing":
             self.status_var.set(self._status_state)
 
+    def _calculate_gradient_color(self, percentage: int, darken: float = 1.0) -> str:
+        """Calculate color gradient from red (0%) to green (100%).
+        
+        Args:
+            percentage: The position in the gradient (0-100)
+            darken: Value between 0.0 (black) and 1.0 (original brightness)
+            
+        Returns:
+            Hex color code string
+        """
+        # Clamp percentage between 0 and 100
+        percentage = max(0, min(100, percentage))
+        # Clamp darken between 0.0 and 1.0
+        darken = max(0.0, min(1.0, darken))
+
+        if percentage <= 50:
+            # Red to Yellow (0% to 50%)
+            # Red: (248, 113, 113) -> Yellow: (250, 204, 21)
+            ratio = percentage / 50.0
+            r = int((248 + (250 - 248) * ratio) * darken)
+            g = int((113 + (204 - 113) * ratio) * darken)
+            b = int((113 + (21 - 113) * ratio) * darken)
+        else:
+            # Yellow to Green (50% to 100%)
+            # Yellow: (250, 204, 21) -> Green: (34, 197, 94)
+            ratio = (percentage - 50) / 50.0
+            r = int((250 + (34 - 250) * ratio) * darken)
+            g = int((204 + (197 - 204) * ratio) * darken)
+            b = int((21 + (94 - 21) * ratio) * darken)
+
+        # Ensure values are within 0-255 range after darkening
+        r = max(0, min(255, r))
+        g = max(0, min(255, g))
+        b = max(0, min(255, b))
+
+        return f"#{r:02x}{g:02x}{b:02x}"
+
+    def _set_progress(self, percentage: int) -> None:
+        """Update the progress bar value and color (thread-safe)."""
+
+        def updater() -> None:
+            self.progress_var.set(percentage)
+            # Update color based on percentage gradient
+            color = self._calculate_gradient_color(percentage, 0.5)
+            palette = (
+                LIGHT_THEME if self._detect_system_theme() == "light" else DARK_THEME
+            )
+            if self.theme_var.get().lower() in {"light", "dark"}:
+                palette = (
+                    LIGHT_THEME
+                    if self.theme_var.get().lower() == "light"
+                    else DARK_THEME
+                )
+
+            self.style.configure(
+                "Dynamic.Horizontal.TProgressbar",
+                background=color,
+                troughcolor=palette["surface"],
+                borderwidth=0,
+                thickness=20,
+            )
+            self.progress_bar.configure(style="Dynamic.Horizontal.TProgressbar")
+
+            # Show stop button when progress < 100
+            if percentage < 100:
+                if hasattr(self, 'status_frame'):
+                    self.status_frame.grid()
+                self.stop_button.grid()
+                self.drop_hint_button.grid_remove()
+        self.root.after(0, updater)
+
+    def _set_progress_bar_style(self, status: str) -> None:
+        """Update the progress bar color based on status."""
+
+        def updater() -> None:
+            # Map status to progress bar style
+            status_lower = status.lower()
+            if status_lower == "success":
+                style = "Success.Horizontal.TProgressbar"
+            elif status_lower == "error":
+                style = "Error.Horizontal.TProgressbar"
+            elif status_lower == "aborted":
+                style = "Aborted.Horizontal.TProgressbar"
+            elif status_lower == "idle":
+                style = "Idle.Horizontal.TProgressbar"
+            else:
+                # For processing states, use dynamic gradient (will be set by _set_progress)
+                return
+
+            self.progress_bar.configure(style=style)
+
+        self.root.after(0, updater)
+
     def _notify(self, callback: Callable[[], None]) -> None:
         self.root.after(0, callback)
 
@@ -996,7 +1361,21 @@ def main(argv: Optional[Sequence[str]] = None) -> bool:
                 print()
                 print("Run 'python3 -m talks_reducer --help' for all options.")
                 print()
-                print("This is likely a macOS/Tkinter compatibility issue.")
+                print("Troubleshooting tips:")
+                if sys.platform == "darwin":
+                    print(
+                        "  - On macOS, install Python from python.org or ensure "
+                        "Homebrew's python-tk package is present."
+                    )
+                elif sys.platform.startswith("linux"):
+                    print(
+                        "  - On Linux, install the Tk bindings for Python (for example, "
+                        "python3-tk)."
+                    )
+                else:
+                    print("  - Ensure your Python installation includes Tk support.")
+                print("  - You can always fall back to the CLI workflow below.")
+                print()
                 print("The CLI interface works perfectly and is recommended.")
             except UnicodeEncodeError:
                 # Fallback for extreme encoding issues

{talks_reducer-0.2.24 → talks_reducer-0.3.0}/talks_reducer/pipeline.py

@@ -157,12 +157,15 @@ def speed_up_video(
         ffmpeg_path=ffmpeg_path,
     )
 
+    reporter.log("Extracting audio...")
+    process_callback = getattr(reporter, 'process_callback', None)
     run_timed_ffmpeg_command(
         extract_command,
         reporter=reporter,
         total=int(original_duration * frame_rate),
         unit="frames",
         desc="Extracting audio:",
+        process_callback=process_callback,
     )
 
     wav_sample_rate, audio_data = wavfile.read(os.fspath(audio_wav))
@@ -249,6 +252,7 @@ def speed_up_video(
             total=updated_chunks[-1][3],
             unit="frames",
             desc="Generating final:",
+            process_callback=process_callback,
         )
     except subprocess.CalledProcessError as exc:
         if fallback_command_str and use_cuda_encoder:
@@ -259,6 +263,7 @@ def speed_up_video(
                 total=updated_chunks[-1][3],
                 unit="frames",
                 desc="Generating final (fallback):",
+                process_callback=process_callback,
             )
         else:
             raise

{talks_reducer-0.2.24 → talks_reducer-0.3.0/talks_reducer.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: talks-reducer
-Version: 0.2.24
+Version: 0.3.0
 Summary: CLI for speeding up long-form talks by removing silence
 Author: Talks Reducer Maintainers
 License-Expression: MIT
@@ -85,6 +85,8 @@ continues to work unchanged for local development.
 - **Input drop zone** — drag files or folders from your desktop or add them via
   the Explorer/Finder dialog; duplicates are ignored.
 - **Small video** — toggles the `--small` preset used by the CLI.
+- **Open after convert** — controls whether the exported file is revealed in
+  your system file manager as soon as each job finishes.
 - **Advanced** — reveals optional controls for the output path, temp folder,
   timing/audio knobs mirrored from the command line, and an appearance picker
   that can force dark or light mode or follow your operating system.
@@ -94,6 +96,10 @@ a background thread. Once every queued job succeeds an **Open last output**
 button appears so you can jump straight to the exported file in your system
 file manager.
 
+The GUI stores your last-used Simple mode, Small video, Open after convert, and
+theme preferences in a cross-platform configuration file so they persist across
+launches.
+
 ## Repository Structure
 - `talks_reducer/` — Python package that exposes the CLI and reusable pipeline:
   - `cli.py` parses arguments and dispatches to the pipeline.