talks-reducer 0.7.2__py3-none-any.whl → 0.8.0__py3-none-any.whl

talks_reducer/gui/__init__.py

@@ -1,1550 +1,21 @@
-"""Minimal Tkinter-based GUI for the talks reducer pipeline."""
+"""Compatibility layer for the Talks Reducer GUI package."""
 
 from __future__ import annotations
 
-import argparse
-import importlib
-import json
-import os
-import re
-import subprocess
-import sys
-import threading
-import time
-from pathlib import Path
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Iterable,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
+from .app import (
+    TalksReducerGUI,
+    _default_remote_destination,
+    _parse_ratios_from_summary,
 )
-
-if TYPE_CHECKING:
-    import tkinter as tk
-    from tkinter import filedialog, messagebox, ttk
-
-try:
-    from ..cli import gather_input_files
-    from ..cli import main as cli_main
-    from ..ffmpeg import FFmpegNotFoundError
-    from ..models import ProcessingOptions
-    from ..pipeline import ProcessingAborted, speed_up_video
-    from ..progress import ProgressHandle, SignalProgressReporter
-    from ..version_utils import resolve_version
-    from .preferences import GUIPreferences, determine_config_path
-    from .remote import (
-        check_remote_server_for_gui,
-        format_server_host,
-        normalize_server_url,
-        ping_server,
-        process_files_via_server,
-    )
-    from .theme import (
-        DARK_THEME,
-        LIGHT_THEME,
-        STATUS_COLORS,
-        apply_theme,
-        detect_system_theme,
-        read_windows_theme_registry,
-        run_defaults_command,
-    )
-except ImportError:  # pragma: no cover - handled at runtime
-    if __package__ not in (None, ""):
-        raise
-
-    PACKAGE_ROOT = Path(__file__).resolve().parent.parent
-    if str(PACKAGE_ROOT) not in sys.path:
-        sys.path.insert(0, str(PACKAGE_ROOT))
-
-    from talks_reducer.cli import gather_input_files
-    from talks_reducer.cli import main as cli_main
-    from talks_reducer.ffmpeg import FFmpegNotFoundError
-    from talks_reducer.gui.preferences import GUIPreferences, determine_config_path
-    from talks_reducer.gui.remote import (
-        check_remote_server_for_gui,
-        format_server_host,
-        normalize_server_url,
-        ping_server,
-        process_files_via_server,
-    )
-    from talks_reducer.gui.theme import (
-        DARK_THEME,
-        LIGHT_THEME,
-        STATUS_COLORS,
-        apply_theme,
-        detect_system_theme,
-        read_windows_theme_registry,
-        run_defaults_command,
-    )
-    from talks_reducer.models import ProcessingOptions
-    from talks_reducer.pipeline import ProcessingAborted, speed_up_video
-    from talks_reducer.progress import ProgressHandle, SignalProgressReporter
-    from talks_reducer.version_utils import resolve_version
-
-
-def _check_tkinter_available() -> tuple[bool, str]:
-    """Check if tkinter can create windows without importing it globally."""
-    # Test in a subprocess to avoid crashing the main process
-    test_code = """
-import json
-
-def run_check():
-    try:
-        import tkinter as tk  # noqa: F401 - imported for side effect
-    except Exception as exc:  # pragma: no cover - runs in subprocess
-        return {
-            "status": "import_error",
-            "error": f"{exc.__class__.__name__}: {exc}",
-        }
-
-    try:
-        import tkinter as tk
-
-        root = tk.Tk()
-        root.destroy()
-    except Exception as exc:  # pragma: no cover - runs in subprocess
-        return {
-            "status": "init_error",
-            "error": f"{exc.__class__.__name__}: {exc}",
-        }
-
-    return {"status": "ok"}
-
-
-if __name__ == "__main__":
-    print(json.dumps(run_check()))
-"""
-
-    try:
-        result = subprocess.run(
-            [sys.executable, "-c", test_code], capture_output=True, text=True, timeout=5
-        )
-
-        output = result.stdout.strip() or result.stderr.strip()
-
-        if not output:
-            return False, "Window creation failed"
-
-        try:
-            payload = json.loads(output)
-        except json.JSONDecodeError:
-            return False, output
-
-        status = payload.get("status")
-
-        if status == "ok":
-            return True, ""
-
-        if status == "import_error":
-            return (
-                False,
-                f"tkinter is not installed ({payload.get('error', 'unknown error')})",
-            )
-
-        if status == "init_error":
-            return (
-                False,
-                f"tkinter could not open a window ({payload.get('error', 'unknown error')})",
-            )
-
-        return False, output
-    except Exception as e:  # pragma: no cover - defensive fallback
-        return False, f"Error testing tkinter: {e}"
-
-
-try:
-    from tkinterdnd2 import DND_FILES, TkinterDnD
-except ModuleNotFoundError:  # pragma: no cover - runtime dependency
-    DND_FILES = None  # type: ignore[assignment]
-    TkinterDnD = None  # type: ignore[assignment]
-
-
-from . import discovery as discovery_helpers
-from . import layout as layout_helpers
-
-
-def _default_remote_destination(input_file: Path, *, small: bool) -> Path:
-    """Return the default remote output path for *input_file*.
-
-    Mirrors the naming scheme from the local pipeline so that remote jobs save
-    next to the source media with the expected suffix.
-    """
-
-    name = input_file.name
-    dot_index = name.rfind(".")
-    suffix = "_speedup_small" if small else "_speedup"
-
-    if dot_index != -1:
-        new_name = name[:dot_index] + suffix + name[dot_index:]
-    else:
-        new_name = name + suffix
-
-    return input_file.with_name(new_name)
-
-
-def _parse_ratios_from_summary(summary: str) -> Tuple[Optional[float], Optional[float]]:
-    """Extract time and size ratios from a Markdown *summary* string."""
-
-    time_ratio: Optional[float] = None
-    size_ratio: Optional[float] = None
-
-    for line in summary.splitlines():
-        if "**Duration:**" in line:
-            match = re.search(r"—\s*([0-9]+(?:\.[0-9]+)?)% of the original", line)
-            if match:
-                try:
-                    time_ratio = float(match.group(1)) / 100
-                except ValueError:
-                    time_ratio = None
-        elif "**Size:**" in line:
-            match = re.search(r"\*\*Size:\*\*\s*([0-9]+(?:\.[0-9]+)?)%", line)
-            if match:
-                try:
-                    size_ratio = float(match.group(1)) / 100
-                except ValueError:
-                    size_ratio = None
-
-    return time_ratio, size_ratio
-
-
-class _GuiProgressHandle(ProgressHandle):
-    """Simple progress handle that records totals but only logs milestones."""
-
-    def __init__(self, log_callback: Callable[[str], None], desc: str) -> None:
-        self._log_callback = log_callback
-        self._desc = desc
-        self._current = 0
-        self._total: Optional[int] = None
-        if desc:
-            self._log_callback(f"{desc} started")
-
-    @property
-    def current(self) -> int:
-        return self._current
-
-    def ensure_total(self, total: int) -> None:
-        if self._total is None or total > self._total:
-            self._total = total
-
-    def advance(self, amount: int) -> None:
-        if amount > 0:
-            self._current += amount
-
-    def finish(self) -> None:
-        if self._total is not None:
-            self._current = self._total
-        if self._desc:
-            self._log_callback(f"{self._desc} completed")
-
-    def __enter__(self) -> "_GuiProgressHandle":
-        return self
-
-    def __exit__(self, exc_type, exc, tb) -> bool:
-        if exc_type is None:
-            self.finish()
-        return False
-
-
-class _TkProgressReporter(SignalProgressReporter):
-    """Progress reporter that forwards updates to the GUI thread."""
-
-    def __init__(
-        self,
-        log_callback: Callable[[str], None],
-        process_callback: Optional[Callable] = None,
-        *,
-        stop_callback: Optional[Callable[[], bool]] = None,
-    ) -> None:
-        self._log_callback = log_callback
-        self.process_callback = process_callback
-        self._stop_callback = stop_callback
-
-    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 = ""
-    ) -> _GuiProgressHandle:
-        del total, unit
-        return _GuiProgressHandle(self._log_callback, desc)
-
-    def stop_requested(self) -> bool:
-        """Return ``True`` when the GUI has asked to cancel processing."""
-
-        if self._stop_callback is None:
-            return False
-        return bool(self._stop_callback())
-
-
-class TalksReducerGUI:
-    """Tkinter application mirroring the CLI options with form controls."""
-
-    PADDING = 10
-    AUDIO_PROCESSING_RATIO = 0.02
-    AUDIO_PROGRESS_STEPS = 20
-    MIN_AUDIO_INTERVAL_MS = 10
-    DEFAULT_AUDIO_INTERVAL_MS = 200
-
-    def __init__(
-        self,
-        initial_inputs: Optional[Sequence[str]] = None,
-        *,
-        auto_run: bool = False,
-    ) -> None:
-        self._config_path = determine_config_path()
-        self.preferences = GUIPreferences(self._config_path)
-
-        # Import tkinter here to avoid loading it at module import time
-        import tkinter as tk
-        from tkinter import filedialog, messagebox, ttk
-
-        # Store references for use in methods
-        self.tk = tk
-        self.filedialog = filedialog
-        self.messagebox = messagebox
-        self.ttk = ttk
-
-        if TkinterDnD is not None:
-            self.root = TkinterDnD.Tk()  # type: ignore[call-arg]
-        else:
-            self.root = tk.Tk()
-
-        # Set window title with version information
-        app_version = resolve_version()
-        if app_version and app_version != "unknown":
-            self.root.title(f"Talks Reducer v{app_version}")
-        else:
-            self.root.title("Talks Reducer")
-
-        self._apply_window_icon()
-
-        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)
-
-        self._processing_thread: Optional[threading.Thread] = None
-        self._last_output: Optional[Path] = None
-        self._last_time_ratio: Optional[float] = None
-        self._last_size_ratio: Optional[float] = None
-        self._last_progress_seconds: Optional[int] = None
-        self._run_start_time: Optional[float] = None
-        self._status_state = "Idle"
-        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._encode_target_duration_seconds: Optional[float] = None
-        self._encode_total_frames: Optional[int] = None
-        self._encode_current_frame: Optional[int] = None
-        self._source_duration_seconds: Optional[float] = None
-        self._audio_progress_job: Optional[str] = None
-        self._audio_progress_interval_ms: Optional[int] = None
-        self._audio_progress_steps_completed = 0
-        self.progress_var = tk.IntVar(value=0)
-        self._ffmpeg_process: Optional[subprocess.Popen] = None
-        self._stop_requested = False
-        self._ping_worker_stop_requested = False
-        self._current_remote_mode = 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=self.preferences.get("simple_mode", True)
-        )
-        self.run_after_drop_var = tk.BooleanVar(value=True)
-        self.small_var = tk.BooleanVar(value=self.preferences.get("small_video", True))
-        self.open_after_convert_var = tk.BooleanVar(
-            value=self.preferences.get("open_after_convert", True)
-        )
-        stored_mode = str(self.preferences.get("processing_mode", "local"))
-        if stored_mode not in {"local", "remote"}:
-            stored_mode = "local"
-        self.processing_mode_var = tk.StringVar(value=stored_mode)
-        self.processing_mode_var.trace_add("write", self._on_processing_mode_change)
-        self.theme_var = tk.StringVar(value=self.preferences.get("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.server_url_var = tk.StringVar(
-            value=str(self.preferences.get("server_url", ""))
-        )
-        self.server_url_var.trace_add("write", self._on_server_url_change)
-        self._discovery_thread: Optional[threading.Thread] = None
-
-        self._basic_defaults: dict[str, float] = {}
-        self._basic_variables: dict[str, tk.DoubleVar] = {}
-        self._slider_updaters: dict[str, Callable[[str], None]] = {}
-        self._sliders: list[tk.Scale] = []
-
-        self._build_layout()
-        self._apply_simple_mode(initial=True)
-        self._apply_status_style(self._status_state)
-        self._refresh_theme()
-        self.preferences.save()
-        self._hide_stop_button()
-
-        # Ping server on startup if in remote mode
-        if (
-            self.processing_mode_var.get() == "remote"
-            and self.server_url_var.get().strip()
-        ):
-            server_url = self.server_url_var.get().strip()
-
-            def ping_worker() -> None:
-                try:
-                    self._check_remote_server(
-                        server_url,
-                        success_status="Idle",
-                        waiting_status="Error",
-                        failure_status="Error",
-                        stop_check=lambda: self._ping_worker_stop_requested,
-                        switch_to_local_on_failure=True,
-                    )
-                except Exception as exc:  # pragma: no cover - defensive safeguard
-                    host_label = self._format_server_host(server_url)
-                    message = f"Error pinging server {host_label}: {exc}"
-                    self._schedule_on_ui_thread(
-                        lambda msg=message: self._append_log(msg)
-                    )
-                    self._schedule_on_ui_thread(
-                        lambda msg=message: self._set_status("Idle", msg)
-                    )
-
-            threading.Thread(target=ping_worker, daemon=True).start()
-
-        if not self._dnd_available:
-            self._append_log(
-                "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)
-
-    def _start_run(self) -> None:
-        if self._processing_thread and self._processing_thread.is_alive():
-            self.messagebox.showinfo("Processing", "A job is already running.")
-            return
-
-        if not self.input_files:
-            self.messagebox.showwarning(
-                "Missing input", "Please add at least one file or folder."
-            )
-            return
-
-        try:
-            args = self._collect_arguments()
-        except ValueError as exc:
-            self.messagebox.showerror("Invalid value", str(exc))
-            return
-
-        self._append_log("Starting processing…")
-        self._stop_requested = False
-        self.stop_button.configure(text="Stop")
-        self._run_start_time = time.monotonic()
-        self._ping_worker_stop_requested = True
-        open_after_convert = bool(self.open_after_convert_var.get())
-        server_url = self.server_url_var.get().strip()
-        remote_mode = self.processing_mode_var.get() == "remote"
-        if remote_mode and not server_url:
-            self.messagebox.showerror(
-                "Missing server URL", "Remote mode requires a server URL."
-            )
-        remote_mode = remote_mode and bool(server_url)
-
-        # Store remote_mode for use after thread starts
-        self._current_remote_mode = remote_mode
-
-        def worker() -> None:
-            def set_process(proc: subprocess.Popen) -> None:
-                self._ffmpeg_process = proc
-
-            try:
-                files = gather_input_files(self.input_files)
-                if not files:
-                    self._schedule_on_ui_thread(
-                        lambda: self.messagebox.showwarning(
-                            "No files", "No supported media files were found."
-                        )
-                    )
-                    self._set_status("Idle")
-                    return
-
-                if self._current_remote_mode:
-                    success = self._process_files_via_server(
-                        files,
-                        args,
-                        server_url,
-                        open_after_convert=open_after_convert,
-                    )
-                    if success:
-                        self._schedule_on_ui_thread(self._hide_stop_button)
-                        return
-                    # If server processing failed, fall back to local processing
-                    # The _process_files_via_server function already switched to local mode
-                    # Update remote_mode variable to reflect the change
-                    self._current_remote_mode = False
-
-                reporter = _TkProgressReporter(
-                    self._append_log,
-                    process_callback=set_process,
-                    stop_callback=lambda: self._stop_requested,
-                )
-                for index, file in enumerate(files, start=1):
-                    self._append_log(f"Processing: {os.path.basename(file)}")
-                    options = self._create_processing_options(Path(file), args)
-                    result = speed_up_video(options, reporter=reporter)
-                    self._last_output = result.output_file
-                    self._last_time_ratio = result.time_ratio
-                    self._last_size_ratio = result.size_ratio
-
-                    # Create completion message with ratios if available
-                    completion_msg = f"Completed: {result.output_file}"
-                    if result.time_ratio is not None and result.size_ratio is not None:
-                        completion_msg += f" (Time: {result.time_ratio:.2%}, Size: {result.size_ratio:.2%})"
-
-                    self._append_log(completion_msg)
-                    if open_after_convert:
-                        self._schedule_on_ui_thread(
-                            lambda path=result.output_file: self._open_in_file_manager(
-                                path
-                            )
-                        )
-
-                self._append_log("All jobs finished successfully.")
-                self._schedule_on_ui_thread(
-                    lambda: self.open_button.configure(state=self.tk.NORMAL)
-                )
-                self._schedule_on_ui_thread(self._clear_input_files)
-            except FFmpegNotFoundError as exc:
-                self._schedule_on_ui_thread(
-                    lambda: self.messagebox.showerror("FFmpeg not found", str(exc))
-                )
-                self._set_status("Error")
-            except ProcessingAborted:
-                self._append_log("Processing aborted by user.")
-                self._set_status("Aborted")
-            except Exception as exc:  # pragma: no cover - GUI level safeguard
-                # 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:
-                    error_msg = f"Processing failed: {exc}"
-                    self._append_log(error_msg)
-                    print(error_msg, file=sys.stderr)  # Also output to console
-                    self._schedule_on_ui_thread(
-                        lambda: self.messagebox.showerror("Error", error_msg)
-                    )
-                    self._set_status("Error")
-            finally:
-                self._run_start_time = None
-                self._schedule_on_ui_thread(self._hide_stop_button)
-
-        self._processing_thread = threading.Thread(target=worker, daemon=True)
-        self._processing_thread.start()
-
-        # Show Stop button when processing starts regardless of mode
-        self.stop_button.grid()
-
-    # ------------------------------------------------------------------ UI --
-    def _apply_window_icon(self) -> None:
-        layout_helpers.apply_window_icon(self)
-
-    def _build_layout(self) -> None:
-        layout_helpers.build_layout(self)
-
-    def _update_basic_reset_state(self) -> None:
-        layout_helpers.update_basic_reset_state(self)
-
-    def _reset_basic_defaults(self) -> None:
-        layout_helpers.reset_basic_defaults(self)
-
-    def _update_processing_mode_state(self) -> None:
-        has_url = bool(self.server_url_var.get().strip())
-        if not has_url and self.processing_mode_var.get() == "remote":
-            self.processing_mode_var.set("local")
-            return
-
-        if hasattr(self, "remote_mode_button"):
-            state = self.tk.NORMAL if has_url else self.tk.DISABLED
-            self.remote_mode_button.configure(state=state)
-
-    def _normalize_server_url(self, server_url: str) -> str:
-        return normalize_server_url(server_url)
-
-    def _format_server_host(self, server_url: str) -> str:
-        return format_server_host(server_url)
-
-    def _check_remote_server(
-        self,
-        server_url: str,
-        *,
-        success_status: str,
-        waiting_status: str,
-        failure_status: str,
-        success_message: Optional[str] = None,
-        waiting_message_template: str = "Waiting server {host} (attempt {attempt}/{max_attempts})",
-        failure_message: Optional[str] = None,
-        stop_check: Optional[Callable[[], bool]] = None,
-        on_stop: Optional[Callable[[], None]] = None,
-        switch_to_local_on_failure: bool = False,
-        alert_on_failure: bool = False,
-        warning_title: str = "Server unavailable",
-        warning_message: Optional[str] = None,
-        max_attempts: int = 5,
-        delay: float = 1.0,
-    ) -> bool:
-        return check_remote_server_for_gui(
-            self,
-            server_url,
-            success_status=success_status,
-            waiting_status=waiting_status,
-            failure_status=failure_status,
-            success_message=success_message,
-            waiting_message_template=waiting_message_template,
-            failure_message=failure_message,
-            stop_check=stop_check,
-            on_stop=on_stop,
-            switch_to_local_on_failure=switch_to_local_on_failure,
-            alert_on_failure=alert_on_failure,
-            warning_title=warning_title,
-            warning_message=warning_message,
-            max_attempts=max_attempts,
-            delay=delay,
-        )
-
-    def _ping_server(self, server_url: str, *, timeout: float = 5.0) -> bool:
-        return ping_server(server_url, timeout=timeout)
-
-    def _start_discovery(self) -> None:
-        discovery_helpers.start_discovery(self)
-
-    def _on_discovery_failed(self, exc: Exception) -> None:
-        discovery_helpers.on_discovery_failed(self, exc)
-
-    def _on_discovery_progress(self, current: int, total: int) -> None:
-        discovery_helpers.on_discovery_progress(self, current, total)
-
-    def _on_discovery_complete(self, urls: List[str]) -> None:
-        discovery_helpers.on_discovery_complete(self, urls)
-
-    def _show_discovery_results(self, urls: List[str]) -> None:
-        discovery_helpers.show_discovery_results(self, urls)
-
-    def _toggle_simple_mode(self) -> None:
-        self.preferences.update("simple_mode", self.simple_mode_var.get())
-        self._apply_simple_mode()
-
-    def _apply_simple_mode(self, *, initial: bool = False) -> None:
-        layout_helpers.apply_simple_mode(self, initial=initial)
-
-    def _apply_window_size(self, *, simple: bool) -> None:
-        layout_helpers.apply_window_size(self, simple=simple)
-
-    def _toggle_advanced(self, *, initial: bool = False) -> None:
-        if not initial:
-            self.advanced_visible.set(not self.advanced_visible.get())
-        visible = self.advanced_visible.get()
-        if visible:
-            self.advanced_frame.grid()
-            self.advanced_button.configure(text="Hide advanced")
-        else:
-            self.advanced_frame.grid_remove()
-            self.advanced_button.configure(text="Advanced")
-
-    def _on_theme_change(self, *_: object) -> None:
-        self.preferences.update("theme", self.theme_var.get())
-        self._refresh_theme()
-
-    def _on_small_video_change(self, *_: object) -> None:
-        self.preferences.update("small_video", bool(self.small_var.get()))
-
-    def _on_open_after_convert_change(self, *_: object) -> None:
-        self.preferences.update(
-            "open_after_convert", bool(self.open_after_convert_var.get())
-        )
-
-    def _on_processing_mode_change(self, *_: object) -> None:
-        value = self.processing_mode_var.get()
-        if value not in {"local", "remote"}:
-            self.processing_mode_var.set("local")
-            return
-        self.preferences.update("processing_mode", value)
-        self._update_processing_mode_state()
-
-        if self.processing_mode_var.get() == "remote":
-            server_url = self.server_url_var.get().strip()
-            if not server_url:
-                return
-
-            def ping_remote_mode() -> None:
-                self._check_remote_server(
-                    server_url,
-                    success_status="Idle",
-                    waiting_status="Error",
-                    failure_status="Error",
-                    failure_message="Server {host} is unreachable. Switching to local mode.",
-                    switch_to_local_on_failure=True,
-                    alert_on_failure=True,
-                    warning_message="Server {host} is unreachable. Switching to local mode.",
-                )
-
-            threading.Thread(target=ping_remote_mode, daemon=True).start()
-
-    def _on_server_url_change(self, *_: object) -> None:
-        value = self.server_url_var.get().strip()
-        self.preferences.update("server_url", value)
-        self._update_processing_mode_state()
-
-    def _resolve_theme_mode(self) -> str:
-        preference = self.theme_var.get().lower()
-        if preference not in {"light", "dark"}:
-            return detect_system_theme(
-                os.environ,
-                sys.platform,
-                read_windows_theme_registry,
-                run_defaults_command,
-            )
-        return preference
-
-    def _refresh_theme(self) -> None:
-        mode = self._resolve_theme_mode()
-        palette = LIGHT_THEME if mode == "light" else DARK_THEME
-        apply_theme(
-            self.style,
-            palette,
-            {
-                "root": self.root,
-                "drop_zone": getattr(self, "drop_zone", None),
-                "log_text": getattr(self, "log_text", None),
-                "status_label": getattr(self, "status_label", None),
-                "sliders": getattr(self, "_sliders", []),
-                "tk": self.tk,
-                "apply_status_style": self._apply_status_style,
-                "status_state": self._status_state,
-            },
-        )
-
-    def _configure_drop_targets(self, widget) -> None:
-        if not self._dnd_available:
-            return
-        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)
-                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."""
-
-        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:
-        directory = self.filedialog.askdirectory(title="Select input folder")
-        if directory:
-            self._extend_inputs([directory])
-
-    def _extend_inputs(self, paths: Iterable[str], *, auto_run: bool = False) -> None:
-        added = False
-        for path in paths:
-            if path and path not in self.input_files:
-                self.input_files.append(path)
-                added = True
-        if auto_run and added and self.run_after_drop_var.get():
-            self._start_run()
-
-    def _clear_input_files(self) -> None:
-        """Clear all queued input files."""
-        self.input_files.clear()
-
-    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._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
-        if "folder" in label.lower():
-            result = self.filedialog.askdirectory()
-        else:
-            initial = variable.get() or os.getcwd()
-            result = self.filedialog.asksaveasfilename(
-                initialfile=os.path.basename(initial)
-            )
-        if result:
-            variable.set(result)
-
-    def _stop_processing(self) -> None:
-        """Stop the currently running processing by terminating FFmpeg."""
-        import signal
-
-        self._stop_requested = True
-        # Update button text to indicate stopping state
-        self.stop_button.configure(text="Stopping...")
-        if self._current_remote_mode:
-            self._append_log("Cancelling remote job...")
-        elif 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] = {}
-
-        if self.output_var.get():
-            args["output_file"] = Path(self.output_var.get())
-        if self.temp_var.get():
-            args["temp_folder"] = Path(self.temp_var.get())
-        silent_threshold = float(self.silent_threshold_var.get())
-        args["silent_threshold"] = round(silent_threshold, 2)
-
-        sounded_speed = float(self.sounded_speed_var.get())
-        args["sounded_speed"] = round(sounded_speed, 2)
-
-        silent_speed = float(self.silent_speed_var.get())
-        args["silent_speed"] = round(silent_speed, 2)
-        if self.frame_margin_var.get():
-            args["frame_spreadage"] = int(
-                round(self._parse_float(self.frame_margin_var.get(), "Frame margin"))
-            )
-        if self.sample_rate_var.get():
-            args["sample_rate"] = int(
-                round(self._parse_float(self.sample_rate_var.get(), "Sample rate"))
-            )
-        if self.small_var.get():
-            args["small"] = True
-        return args
-
-    def _process_files_via_server(
-        self,
-        files: List[str],
-        args: dict[str, object],
-        server_url: str,
-        *,
-        open_after_convert: bool,
-    ) -> bool:
-        """Send *files* to the configured server for processing."""
-
-        return process_files_via_server(
-            self,
-            files,
-            args,
-            server_url,
-            open_after_convert=open_after_convert,
-            default_remote_destination=_default_remote_destination,
-            parse_summary=_parse_ratios_from_summary,
-        )
-
-    def _parse_float(self, value: str, label: str) -> float:
-        try:
-            return float(value)
-        except ValueError as exc:  # pragma: no cover - input validation
-            raise ValueError(f"{label} must be a number.") from exc
-
-    def _create_processing_options(
-        self, input_file: Path, args: dict[str, object]
-    ) -> ProcessingOptions:
-        options = dict(args)
-        options["input_file"] = input_file
-
-        if "temp_folder" in options:
-            options["temp_folder"] = Path(options["temp_folder"])
-
-        return ProcessingOptions(**options)
-
-    def _open_last_output(self) -> None:
-        if self._last_output is not None:
-            self._open_in_file_manager(self._last_output)
-
-    def _open_in_file_manager(self, path: Path) -> None:
-        target = Path(path)
-        if sys.platform.startswith("win"):
-            command = ["explorer", f"/select,{target}"]
-        elif sys.platform == "darwin":
-            command = ["open", "-R", os.fspath(target)]
-        else:
-            command = [
-                "xdg-open",
-                os.fspath(target.parent if target.exists() else target),
-            ]
-        try:
-            subprocess.Popen(command)
-        except OSError:
-            self._append_log(f"Could not open file manager for {target}")
-
-    def _append_log(self, message: str) -> None:
-        self._update_status_from_message(message)
-
-        def updater() -> None:
-            self.log_text.configure(state=self.tk.NORMAL)
-            self.log_text.insert(self.tk.END, message + "\n")
-            self.log_text.see(self.tk.END)
-            self.log_text.configure(state=self.tk.DISABLED)
-
-        self.log_text.after(0, updater)
-
-    def _update_status_from_message(self, message: str) -> None:
-        normalized = message.strip().lower()
-        metadata_match = re.search(
-            r"source metadata: duration:\s*([\d.]+)s",
-            message,
-            re.IGNORECASE,
-        )
-        if metadata_match:
-            try:
-                self._source_duration_seconds = float(metadata_match.group(1))
-            except ValueError:
-                self._source_duration_seconds = None
-        if "all jobs finished successfully" in normalized:
-            status_components: List[str] = []
-            if self._run_start_time is not None:
-                finish_time = time.monotonic()
-                runtime_seconds = max(0.0, finish_time - self._run_start_time)
-                duration_str = self._format_progress_time(runtime_seconds)
-                status_components.append(f"{duration_str}")
-            else:
-                finished_seconds = next(
-                    (
-                        value
-                        for value in (
-                            self._last_progress_seconds,
-                            self._encode_target_duration_seconds,
-                            self._video_duration_seconds,
-                        )
-                        if value is not None
-                    ),
-                    None,
-                )
-
-                if finished_seconds is not None:
-                    duration_str = self._format_progress_time(finished_seconds)
-                    status_components.append(f"{duration_str}")
-                else:
-                    status_components.append("Finished")
-
-            if self._last_time_ratio is not None and self._last_size_ratio is not None:
-                status_components.append(
-                    f"time: {self._last_time_ratio:.0%}, size: {self._last_size_ratio:.0%}"
-                )
-
-            status_msg = ", ".join(status_components)
-
-            self._reset_audio_progress_state(clear_source=True)
-            self._set_status("success", status_msg)
-            self._set_progress(100)  # 100% on success
-            self._run_start_time = None
-            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
-            self._last_progress_seconds = None
-        elif normalized.startswith("extracting audio"):
-            self._reset_audio_progress_state(clear_source=False)
-            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
-            self._last_progress_seconds = None
-            self._start_audio_progress()
-        elif normalized.startswith("uploading"):
-            self._set_status("processing", "Uploading...")
-        elif normalized.startswith("starting processing"):
-            self._reset_audio_progress_state(clear_source=True)
-            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
-            self._last_progress_seconds = None
-        elif normalized.startswith("processing"):
-            is_new_job = bool(re.match(r"processing \d+/\d+:", normalized))
-            should_reset = self._status_state.lower() != "processing" or is_new_job
-            if should_reset:
-                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
-                self._last_progress_seconds = None
-            if is_new_job:
-                self._reset_audio_progress_state(clear_source=True)
-            self._set_status("processing", "Processing")
-
-        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:
-                    self._complete_audio_phase()
-                    frame_ratio = min(current_frame / self._encode_total_frames, 1.0)
-                    percentage = min(100, 5 + int(frame_ratio * 95))
-                    self._set_progress(percentage)
-                else:
-                    self._complete_audio_phase()
-                    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)
-        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))
-            current_seconds = hours * 3600 + minutes * 60 + seconds
-            time_str = self._format_progress_time(current_seconds)
-            speed_str = speed_match.group(1)
-
-            self._last_progress_seconds = current_seconds
-
-            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:
-                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
-            ):
-                self._complete_audio_phase()
-                time_ratio = min(current_seconds / total_seconds, 1.0)
-                percentage = min(100, 5 + int(time_ratio * 95))
-                self._set_progress(percentage)
-
-            self._set_status("processing", status_msg)
-
-    def _compute_audio_progress_interval(self) -> int:
-        duration = self._source_duration_seconds or self._video_duration_seconds
-        if duration and duration > 0:
-            audio_seconds = max(duration * self.AUDIO_PROCESSING_RATIO, 0.0)
-            interval_seconds = audio_seconds / self.AUDIO_PROGRESS_STEPS
-            interval_ms = int(round(interval_seconds * 1000))
-            return max(self.MIN_AUDIO_INTERVAL_MS, interval_ms)
-        return self.DEFAULT_AUDIO_INTERVAL_MS
-
-    def _start_audio_progress(self) -> None:
-        interval_ms = self._compute_audio_progress_interval()
-
-        def _start() -> None:
-            if self._audio_progress_job is not None:
-                self.root.after_cancel(self._audio_progress_job)
-            self._audio_progress_steps_completed = 0
-            self._audio_progress_interval_ms = interval_ms
-            self._audio_progress_job = self.root.after(
-                interval_ms, self._advance_audio_progress
-            )
-
-        self._schedule_on_ui_thread(_start)
-
-    def _advance_audio_progress(self) -> None:
-        self._audio_progress_job = None
-        if self._audio_progress_steps_completed >= self.AUDIO_PROGRESS_STEPS:
-            self._audio_progress_interval_ms = None
-            return
-
-        self._audio_progress_steps_completed += 1
-        audio_percentage = (
-            self._audio_progress_steps_completed / self.AUDIO_PROGRESS_STEPS * 100
-        )
-        percentage = (audio_percentage / 100) * 5
-        self._set_progress(percentage)
-        self._set_status("processing", "Audio processing: %d%%" % (audio_percentage))
-
-        if self._audio_progress_steps_completed < self.AUDIO_PROGRESS_STEPS:
-            interval_ms = (
-                self._audio_progress_interval_ms or self.DEFAULT_AUDIO_INTERVAL_MS
-            )
-            self._audio_progress_job = self.root.after(
-                interval_ms, self._advance_audio_progress
-            )
-        else:
-            self._audio_progress_interval_ms = None
-
-    def _cancel_audio_progress(self) -> None:
-        if self._audio_progress_job is None:
-            self._audio_progress_interval_ms = None
-            return
-
-        def _cancel() -> None:
-            if self._audio_progress_job is not None:
-                self.root.after_cancel(self._audio_progress_job)
-                self._audio_progress_job = None
-            self._audio_progress_interval_ms = None
-
-        self._schedule_on_ui_thread(_cancel)
-
-    def _reset_audio_progress_state(self, *, clear_source: bool) -> None:
-        if clear_source:
-            self._source_duration_seconds = None
-        self._audio_progress_steps_completed = 0
-        self._audio_progress_interval_ms = None
-        if self._audio_progress_job is not None:
-            self._cancel_audio_progress()
-
-    def _complete_audio_phase(self) -> None:
-        def _complete() -> None:
-            if self._audio_progress_job is not None:
-                self.root.after_cancel(self._audio_progress_job)
-                self._audio_progress_job = None
-            self._audio_progress_interval_ms = None
-            if self._audio_progress_steps_completed < self.AUDIO_PROGRESS_STEPS:
-                self._audio_progress_steps_completed = self.AUDIO_PROGRESS_STEPS
-                current_value = self.progress_var.get()
-                if current_value < self.AUDIO_PROGRESS_STEPS:
-                    self._set_progress(self.AUDIO_PROGRESS_STEPS)
-
-        self._schedule_on_ui_thread(_complete)
-
-    def _apply_status_style(self, status: str) -> None:
-        color = STATUS_COLORS.get(status.lower())
-        if color:
-            self.status_label.configure(fg=color)
-        else:
-            # For extracting audio or FFmpeg progress messages, use processing color
-            # Also handle the new "Time: X%, Size: Y%" format as success
-            status_lower = status.lower()
-            if (
-                "extracting audio" in status_lower
-                or re.search(
-                    r"\d+:\d{2}(?::\d{2})?(?: / \d+:\d{2}(?::\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:
-                    # This is our new success format with ratios
-                    self.status_label.configure(fg=STATUS_COLORS["success"])
-                else:
-                    self.status_label.configure(fg=STATUS_COLORS["processing"])
-
-    def _set_status(self, status: str, status_msg: str = "") -> None:
-        def apply() -> None:
-            self._status_state = status
-            # Use status_msg if provided, otherwise use status
-            display_text = status_msg if status_msg else status
-            self.status_var.set(display_text)
-            self._apply_status_style(
-                status
-            )  # Colors depend on status, not display text
-            self._set_progress_bar_style(status)
-            lowered = status.lower()
-            is_processing = lowered == "processing" or "extracting audio" in lowered
-
-            if is_processing:
-                # Show stop button during processing
-                if hasattr(self, "status_frame"):
-                    self.status_frame.grid()
-                self.stop_button.grid()
-                self.drop_hint_button.grid_remove()
-            else:
-                self._reset_audio_progress_state(clear_source=True)
-
-            if lowered == "success" or "time:" in lowered and "size:" in lowered:
-                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()
-                # print("not success status")
-                if self.simple_mode_var.get() and not is_processing:
-                    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)
-
-    def _format_progress_time(self, total_seconds: float) -> str:
-        """Format a duration in seconds as h:mm:ss 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}:{seconds: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%).
-
-        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._resolve_theme_mode() == "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" or (
-                "time:" in status_lower and "size:" in status_lower
-            ):
-                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 _schedule_on_ui_thread(self, callback: Callable[[], None]) -> None:
-        self.root.after(0, callback)
-
-    def run(self) -> None:
-        """Start the Tkinter event loop."""
-
-        self.root.mainloop()
-
-
-def main(argv: Optional[Sequence[str]] = None) -> bool:
-    """Launch the GUI when run without arguments, otherwise defer to the CLI.
-
-    Returns ``True`` if the GUI event loop started successfully. ``False``
-    indicates that execution was delegated to the CLI or aborted early.
-    """
-
-    if argv is None:
-        argv = sys.argv[1:]
-
-    parser = argparse.ArgumentParser(add_help=False)
-    parser.add_argument(
-        "--server",
-        action="store_true",
-        help="Launch the Talks Reducer server tray instead of the desktop GUI.",
-    )
-    parser.add_argument(
-        "--no-tray",
-        action="store_true",
-        help="Deprecated: the GUI no longer starts the server tray automatically.",
-    )
-
-    parsed_args, remaining = parser.parse_known_args(argv)
-    if parsed_args.server:
-        package_name = __package__ or "talks_reducer"
-        module_name = f"{package_name}.server_tray"
-        try:
-            tray_module = importlib.import_module(module_name)
-        except ModuleNotFoundError as exc:
-            if exc.name != module_name:
-                raise
-            root_package = package_name.split(".")[0] or "talks_reducer"
-            tray_module = importlib.import_module(f"{root_package}.server_tray")
-        tray_main = getattr(tray_module, "main")
-        tray_main(remaining)
-        return False
-    if parsed_args.no_tray:
-        sys.stderr.write(
-            "Warning: --no-tray is deprecated; the GUI no longer starts the server tray automatically.\n"
-        )
-    argv = remaining
-
-    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
-
-    # Skip tkinter check if running as a PyInstaller frozen app
-    # In that case, tkinter is bundled and the subprocess check would fail
-    is_frozen = getattr(sys, "frozen", False)
-
-    if not is_frozen:
-        # Check if tkinter is available before creating GUI (only when not frozen)
-        tkinter_available, error_msg = _check_tkinter_available()
-
-        if not tkinter_available:
-            # Use ASCII-safe output for Windows console compatibility
-            try:
-                print("Talks Reducer GUI")
-                print("=" * 50)
-                print("X GUI not available on this system")
-                print(f"Error: {error_msg}")
-                print()
-                print("! Alternative: Use the command-line interface")
-                print()
-                print("The CLI provides all the same functionality:")
-                print("  python3 -m talks_reducer <input_file> [options]")
-                print()
-                print("Examples:")
-                print("  python3 -m talks_reducer video.mp4")
-                print("  python3 -m talks_reducer video.mp4 --small")
-                print("  python3 -m talks_reducer video.mp4 -o output.mp4")
-                print()
-                print("Run 'python3 -m talks_reducer --help' for all options.")
-                print()
-                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
-                sys.stderr.write("GUI not available. Use CLI mode instead.\n")
-            return False
-
-    # Catch and report any errors during GUI initialization
-    try:
-        app = TalksReducerGUI()
-        app.run()
-        return True
-    except Exception as e:
-        import traceback
-
-        sys.stderr.write(f"Error starting GUI: {e}\n")
-        sys.stderr.write(traceback.format_exc())
-        sys.stderr.write("\nPlease use the CLI mode instead:\n")
-        sys.stderr.write("  python3 -m talks_reducer <input_file> [options]\n")
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()
-
-
-__all__ = ["TalksReducerGUI", "main"]
+from .progress import _GuiProgressHandle, _TkProgressReporter
+from .startup import _check_tkinter_available, main
+
+__all__ = [
+    "TalksReducerGUI",
+    "_GuiProgressHandle",
+    "_TkProgressReporter",
+    "_check_tkinter_available",
+    "_default_remote_destination",
+    "_parse_ratios_from_summary",
+    "main",
+]