talks-reducer 0.2.24__py3-none-any.whl → 0.3.1__py3-none-any.whl

talks_reducer/audio.py

@@ -11,6 +11,8 @@ import numpy as np
 from audiotsm import phasevocoder
 from audiotsm.io.array import ArrayReader, ArrayWriter
 
+from .ffmpeg import get_ffprobe_path
+
 
 def get_max_volume(samples: np.ndarray) -> float:
     """Return the maximum absolute volume in the provided sample array."""
@@ -21,8 +23,6 @@ def get_max_volume(samples: np.ndarray) -> float:
 def is_valid_input_file(filename: str) -> bool:
     """Check whether ``ffprobe`` recognises the input file and finds an audio stream."""
 
-    from .ffmpeg import get_ffprobe_path
-
     ffprobe_path = get_ffprobe_path()
     command = [
         ffprobe_path,
@@ -36,29 +36,31 @@ def is_valid_input_file(filename: str) -> bool:
         "-show_entries",
         "stream=codec_type",
     ]
-    
+
     # Hide console window on Windows
     creationflags = 0
     if sys.platform == "win32":
         # CREATE_NO_WINDOW = 0x08000000
         creationflags = 0x08000000
-    
-    process = subprocess.Popen(
-        command, 
-        stdout=subprocess.PIPE, 
-        stderr=subprocess.PIPE,
-        creationflags=creationflags
-    )
-    outs, errs = None, None
+
     try:
-        outs, errs = process.communicate(timeout=1)
+        result = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            timeout=5,
+            creationflags=creationflags,
+        )
     except subprocess.TimeoutExpired:
         print("Timeout while checking the input file. Aborting. Command:")
         print(" ".join(command))
-        process.kill()
-        outs, errs = process.communicate()
-    finally:
-        return len(errs) == 0 and len(outs) > 0
+        return False
+
+    if result.returncode != 0:
+        return False
+
+    stdout = result.stdout or ""
+    return "codec_type=audio" in stdout
 
 
 def process_audio_chunks(

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/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,16 +385,20 @@ 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)
+        self.drop_zone.configure(cursor="hand2", takefocus=1)
+        self.drop_zone.bind("<Button-1>", self._on_drop_zone_click)
+        self.drop_zone.bind("<Return>", self._on_drop_zone_click)
+        self.drop_zone.bind("<space>", self._on_drop_zone_click)
 
         self.add_files_button = self.ttk.Button(
             input_frame, text="Add files", command=self._add_files
@@ -343,21 +420,32 @@ 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)
 
+        checkbox_frame = self.ttk.Frame(options)
+        checkbox_frame.grid(row=0, column=0, columnspan=2, sticky="w")
+
+        self.ttk.Checkbutton(
+            checkbox_frame,
+            text="Small video",
+            variable=self.small_var,
+        ).grid(row=0, column=0, sticky="w")
+
+        self.ttk.Checkbutton(
+            checkbox_frame,
+            text="Open after convert",
+            variable=self.open_after_convert_var,
+        ).grid(row=0, column=1, sticky="w", padx=(12, 0))
+
         self.simple_mode_check = self.ttk.Checkbutton(
-            options,
+            checkbox_frame,
             text="Simple mode",
             variable=self.simple_mode_var,
             command=self._toggle_simple_mode,
         )
-        self.simple_mode_check.grid(row=0, column=0, sticky="w")
-
-        self.ttk.Checkbutton(options, text="Small video", variable=self.small_var).grid(
-            row=1, column=0, sticky="w", pady=(8, 0)
-        )
+        self.simple_mode_check.grid(row=0, column=2, sticky="w", padx=(12, 0))
 
         self.advanced_visible = self.tk.BooleanVar(value=False)
         self.advanced_button = self.ttk.Button(
@@ -365,9 +453,9 @@ class TalksReducerGUI:
             text="Advanced",
             command=self._toggle_advanced,
         )
-        self.advanced_button.grid(row=0, column=1, sticky="e")
+        self.advanced_button.grid(row=1, column=1, sticky="e")
 
-        self.advanced_frame = self.ttk.Frame(options, padding=(0, 12, 0, 0))
+        self.advanced_frame = self.ttk.Frame(options, padding=self.PADDING)
         self.advanced_frame.grid(row=2, column=0, columnspan=2, sticky="nsew")
         self.advanced_frame.columnconfigure(1, weight=1)
 
@@ -424,33 +512,61 @@ 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.run_button = self.ttk.Button(
-            self.actions_frame, text="Run", command=self._start_run
+        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.run_button.grid(row=0, column=0, sticky="w")
+        self.progress_bar.grid(row=1, column=0, columnspan=3, sticky="ew", pady=(0, 0))
+
+        self.stop_button = self.ttk.Button(
+            status_frame, text="Stop", command=self._stop_processing
+        )
+        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 +602,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 +620,25 @@ 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 +672,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 +702,8 @@ class TalksReducerGUI:
             "TLabelframe",
             background=palette["background"],
             foreground=palette["foreground"],
+            borderwidth=0,
+            relief="flat",
         )
         self.style.configure(
             "TLabelframe.Label",
@@ -586,11 +718,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 +744,7 @@ class TalksReducerGUI:
                 ("disabled", palette["surface"]),
             ],
             foreground=[
-                ("active", palette["surface"]),
+                ("active", palette.get("hover_text", "#000000")),
                 ("disabled", palette["foreground"]),
             ],
         )
@@ -619,11 +759,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"],
@@ -683,14 +859,19 @@ class TalksReducerGUI:
         widget.dnd_bind("<<Drop>>", self._on_drop)  # type: ignore[attr-defined]
 
     # -------------------------------------------------------------- actions --
-    def _add_files(self) -> None:
-        files = self.filedialog.askopenfilenames(
+    def _ask_for_input_files(self) -> tuple[str, ...]:
+        """Prompt the user to select input files for processing."""
+
+        return self.filedialog.askopenfilenames(
             title="Select input files",
             filetypes=[
                 ("Video files", "*.mp4 *.mkv *.mov *.avi *.m4v"),
                 ("All", "*.*"),
             ],
         )
+
+    def _add_files(self) -> None:
+        files = self._ask_for_input_files()
         self._extend_inputs(files)
 
     def _add_directory(self) -> None:
@@ -714,14 +895,32 @@ 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 _on_drop_zone_click(self, event: object) -> str | None:
+        """Open a file selection dialog when the drop zone is activated."""
+
+        files = self._ask_for_input_files()
+        if not files:
+            return "break"
+        self._clear_input_files()
+        self._extend_inputs(files, auto_run=True)
+        return "break"
+
     def _browse_path(
         self, variable, label: str
     ) -> None:  # type: (tk.StringVar, str) -> None
@@ -753,10 +952,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 +981,77 @@ 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 +1136,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 +1196,39 @@ 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 +1256,100 @@ 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 +1401,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/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.dist-info → talks_reducer-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: talks-reducer
-Version: 0.2.24
+Version: 0.3.1
 Summary: CLI for speeding up long-form talks by removing silence
 Author: Talks Reducer Maintainers
 License-Expression: MIT
@@ -9,7 +9,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: audiotsm>=0.1.2
 Requires-Dist: scipy>=1.10.0
-Requires-Dist: numpy<2.0.0,>=1.22.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
@@ -82,9 +82,12 @@ continues to work unchanged for local development.
   zone, hides the manual run controls and log, and automatically processes new
   files as soon as you drop them. Uncheck the box to return to the full layout
   with file pickers, the Run button, and detailed logging.
-- **Input drop zone** — drag files or folders from your desktop or add them via
-  the Explorer/Finder dialog; duplicates are ignored.
+- **Input drop zone** — drag files or folders from your desktop, click to open
+  the system file picker, 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 +97,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.3.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+talks_reducer/__init__.py,sha256=lb50C4_o_SLERyMyVpQfgHnXf49FJOIF9j05MZ8KAvM,158
+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=ZQcay6NF32g0PF7OGLKWPY1TbIR1Hx2xaRlzOXK1lto,6508
+talks_reducer/ffmpeg.py,sha256=tM_T2mV_Y7U91QzWmTBEid9cjEobLpPnxsiOUfz_yDA,11697
+talks_reducer/gui.py,sha256=42gWHLs1LlNvNYp-mEnUmpJd-XpempOF5tWytA5fTRs,53679
+talks_reducer/models.py,sha256=6cZRcJf0EBZIzNd-PWrh4Wdsoa4EBj5nSdB6BnFiOXM,1106
+talks_reducer/pipeline.py,sha256=deGvGMF3CSVd7lcpA7dke8dlLQw3mi_FEhSkFNte7Ro,8871
+talks_reducer/progress.py,sha256=Mh43M6VWhjjUv9CI22xfD2EJ_7Aq3PCueqefQ9Bd5-o,4565
+talks_reducer-0.3.1.dist-info/licenses/LICENSE,sha256=jN17mHNR3e84awmH3AbpWBcBDBzPxEH0rcOFoj1s7sQ,1124
+talks_reducer-0.3.1.dist-info/METADATA,sha256=NU0eHj8kK0bC4Lz-AMjqxlAUhxKuaSgODYVr5iRkT9Y,7660
+talks_reducer-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+talks_reducer-0.3.1.dist-info/entry_points.txt,sha256=LCzfSnh_7VXhvl9twoFSAj0C3sG7bayWs2LkxpH7hoI,100
+talks_reducer-0.3.1.dist-info/top_level.txt,sha256=pJWGcy__LR9JIEKH3QJyFmk9XrIsiFtqvuMNxFdIzDU,14
+talks_reducer-0.3.1.dist-info/RECORD,,

talks_reducer-0.2.24.dist-info/RECORD

@@ -1,16 +0,0 @@
-talks_reducer/__init__.py,sha256=lb50C4_o_SLERyMyVpQfgHnXf49FJOIF9j05MZ8KAvM,158
-talks_reducer/__main__.py,sha256=azR_vh8HFPLaOnh-L6gUFWsL67I6iHtbeH5rQhsipGY,299
-talks_reducer/audio.py,sha256=we6-lyVjCJSFDEFUTPhtpiUmT2MZdPMpBrYN2ED_T9E,4440
-talks_reducer/chunks.py,sha256=IpdZxRFPURSG5wP-OQ_p09CVP8wcKwIFysV29zOTSWI,2959
-talks_reducer/cli.py,sha256=ZQcay6NF32g0PF7OGLKWPY1TbIR1Hx2xaRlzOXK1lto,6508
-talks_reducer/ffmpeg.py,sha256=GzHD1gnC7D3mgQJYZhz0waudDs2x-biI4x7ThrFMP50,11318
-talks_reducer/gui.py,sha256=EVGpQBBu4qz5KgkxIlq7RZqdiBIN_XFCs6-jssK9FGs,37011
-talks_reducer/models.py,sha256=6cZRcJf0EBZIzNd-PWrh4Wdsoa4EBj5nSdB6BnFiOXM,1106
-talks_reducer/pipeline.py,sha256=zcrN8VaWXPc1InY_mXX4yDrQ9goST3G5uBYKkEfJQu4,8623
-talks_reducer/progress.py,sha256=Mh43M6VWhjjUv9CI22xfD2EJ_7Aq3PCueqefQ9Bd5-o,4565
-talks_reducer-0.2.24.dist-info/licenses/LICENSE,sha256=jN17mHNR3e84awmH3AbpWBcBDBzPxEH0rcOFoj1s7sQ,1124
-talks_reducer-0.2.24.dist-info/METADATA,sha256=nmQZPt5hx6jEWH44zxgG_qMMekyfiUYwJoOdXSOw-us,7313
-talks_reducer-0.2.24.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-talks_reducer-0.2.24.dist-info/entry_points.txt,sha256=LCzfSnh_7VXhvl9twoFSAj0C3sG7bayWs2LkxpH7hoI,100
-talks_reducer-0.2.24.dist-info/top_level.txt,sha256=pJWGcy__LR9JIEKH3QJyFmk9XrIsiFtqvuMNxFdIzDU,14
-talks_reducer-0.2.24.dist-info/RECORD,,