tv-recorder 0.0.0.dev3__tar.gz → 0.0.0.dev4__tar.gz

{tv_recorder-0.0.0.dev3 → tv_recorder-0.0.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tv-recorder
-Version: 0.0.0.dev3
+Version: 0.0.0.dev4
 Summary: Command-line recorder for public live TV streams.
 Project-URL: Homepage, https://github.com/onclefranck/tv-recorder
 Project-URL: Repository, https://github.com/onclefranck/tv-recorder
@@ -56,18 +56,34 @@ Description-Content-Type: text/markdown
 
 Command-line recorder for public live TV streams.
 
-## Local Installation
+## Installation
 
 ```powershell
-python -m pip install -e .
+pipx install tv-recorder
 ```
 
 Chromium is installed automatically on first use if Playwright does not already have it.
 
 The recorder uses the `ffmpeg` binary provided by `imageio-ffmpeg`.
 
+For local development from a checkout:
+
+```powershell
+pipx install --editable .
+```
+
 ## Usage
 
+Start `tv-recorder` without arguments to open the native desktop GUI:
+
+```powershell
+tv-recorder
+```
+
+The GUI uses Python's built-in Tkinter toolkit and exposes the common recording
+and Comskip options with a log panel for command output. Custom YAML
+configuration remains available from the CLI.
+
 ```powershell
 tv-recorder radio-canada.ca now 2h
 ```

{tv_recorder-0.0.0.dev3 → tv_recorder-0.0.0.dev4}/README.md

@@ -2,18 +2,34 @@
 
 Command-line recorder for public live TV streams.
 
-## Local Installation
+## Installation
 
 ```powershell
-python -m pip install -e .
+pipx install tv-recorder
 ```
 
 Chromium is installed automatically on first use if Playwright does not already have it.
 
 The recorder uses the `ffmpeg` binary provided by `imageio-ffmpeg`.
 
+For local development from a checkout:
+
+```powershell
+pipx install --editable .
+```
+
 ## Usage
 
+Start `tv-recorder` without arguments to open the native desktop GUI:
+
+```powershell
+tv-recorder
+```
+
+The GUI uses Python's built-in Tkinter toolkit and exposes the common recording
+and Comskip options with a log panel for command output. Custom YAML
+configuration remains available from the CLI.
+
 ```powershell
 tv-recorder radio-canada.ca now 2h
 ```

{tv_recorder-0.0.0.dev3 → tv_recorder-0.0.0.dev4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "tv-recorder"
-version = "0.0.0.dev3"
+version = "0.0.0.dev4"
 description = "Command-line recorder for public live TV streams."
 readme = "README.md"
 requires-python = ">=3.11"

{tv_recorder-0.0.0.dev3 → tv_recorder-0.0.0.dev4}/src/tv_recorder/cli.py

@@ -1,7 +1,10 @@
 from __future__ import annotations
 
 import shlex
+import sys
+import threading
 import time
+from collections.abc import Callable
 from pathlib import Path
 
 import click
@@ -20,7 +23,7 @@ from tv_recorder.stream_finder import find_stream
 @click.argument("duration", required=False)
 @click.option("--config", "config_path", type=click.Path(path_type=Path), help="Path to a YAML source config file.")
 @click.option("--list", "list_channels", is_flag=True, help="List available sources.")
-@click.option("--output-dir", type=click.Path(path_type=Path), default=Path("recordings"), show_default=True, help="Output directory.")
+@click.option("--output-dir", type=click.Path(path_type=Path), default=Path.cwd, show_default="current directory", help="Output directory.")
 @click.option("--headful", is_flag=True, help="Show Chromium while detecting the stream.")
 @click.option("--timeout-ms", type=int, default=45_000, show_default=True, help="Playwright timeout in milliseconds.")
 @click.option("--ffmpeg", "ffmpeg_path", default="ffmpeg", show_default=True, help="Override the bundled imageio-ffmpeg binary.")
@@ -44,6 +47,12 @@ def main(
 ) -> None:
     """Find an HLS stream and record it."""
     try:
+        if _launched_without_arguments():
+            from tv_recorder.gui import main as gui_main
+
+            gui_main()
+            return
+
         config = load_config(config_path)
         if list_channels:
             list_sources(config)
@@ -99,6 +108,9 @@ def run_record_command(
     comskip: bool,
     dry_run: bool,
     log_level: str,
+    activity_callback: Callable[[str], None] | None = None,
+    comskip_activity_callback: Callable[[str], None] | None = None,
+    cancellation_event: threading.Event | None = None,
 ) -> int:
     source = get_source(config, source_key)
     start = parse_start(start_value)
@@ -107,7 +119,13 @@ def run_record_command(
 
     if delay > 0:
         _info(log_level, f"Waiting until {start.isoformat()} ({int(delay)} s).")
-        time.sleep(delay)
+        if cancellation_event and cancellation_event.wait(delay):
+            _info(log_level, "Cancelled before recording started.")
+            return 130
+
+    if cancellation_event and cancellation_event.is_set():
+        _info(log_level, "Cancelled before stream detection.")
+        return 130
 
     _info(log_level, f"Detecting stream for {source.display_name}...")
     stream = find_stream(
@@ -116,6 +134,11 @@ def run_record_command(
         timeout_ms=timeout_ms,
         debug_log=lambda message: _debug(log_level, message),
     )
+
+    if cancellation_event and cancellation_event.is_set():
+        _info(log_level, "Cancelled before recording started.")
+        return 130
+
     output_path = build_output_path(output_dir, source, start)
     plan = build_ffmpeg_plan(
         stream,
@@ -142,7 +165,12 @@ def run_record_command(
         return 0
 
     _info(log_level, f"Recording to {plan.output_path}")
-    exit_code = run_recording(plan, debug=log_level == "debug")
+    exit_code = run_recording(
+        plan,
+        debug=log_level == "debug",
+        activity_callback=activity_callback,
+        cancellation_event=cancellation_event,
+    )
     if exit_code != 0:
         click.echo(f"ffmpeg exited with code {exit_code}.", err=True)
         return exit_code
@@ -153,6 +181,8 @@ def run_record_command(
             plan.output_path,
             ffmpeg_path=plan.ffmpeg_path,
             log_level=log_level,
+            activity_callback=comskip_activity_callback,
+            cancellation_event=cancellation_event,
         )
 
     return 0
@@ -176,6 +206,8 @@ def run_existing_comskip(
     *,
     ffmpeg_path: str,
     log_level: str,
+    activity_callback: Callable[[str], None] | None = None,
+    cancellation_event: threading.Event | None = None,
 ) -> int:
     if not recording_path.exists():
         raise FileNotFoundError(recording_path)
@@ -185,6 +217,8 @@ def run_existing_comskip(
         recording_path,
         ffmpeg_path=resolved_ffmpeg,
         log_level=log_level,
+        activity_callback=activity_callback,
+        cancellation_event=cancellation_event,
     )
 
 
@@ -194,6 +228,8 @@ def run_comskip_pipeline(
     *,
     ffmpeg_path: str,
     log_level: str,
+    activity_callback: Callable[[str], None] | None = None,
+    cancellation_event: threading.Event | None = None,
 ) -> int:
     source_key = _source_key_from_recording(config, recording_path)
     source = get_source(config, source_key) if source_key else None
@@ -210,7 +246,12 @@ def run_comskip_pipeline(
     )
     _info(log_level, f"Running Comskip on {comskip_plan.recording_path}")
     _debug(log_level, f"Comskip command: {shlex.join(comskip_plan.command)}")
-    exit_code = run_comskip(comskip_plan, debug=log_level == "debug")
+    exit_code = run_comskip(
+        comskip_plan,
+        debug=log_level == "debug",
+        activity_callback=activity_callback,
+        cancellation_event=cancellation_event,
+    )
     if exit_code != 0:
         click.echo(f"comskip exited with code {exit_code}.", err=True)
         return exit_code
@@ -221,6 +262,8 @@ def run_comskip_pipeline(
         comskip_plan,
         ffmpeg_path=ffmpeg_path,
         debug=log_level == "debug",
+        activity_callback=activity_callback,
+        cancellation_event=cancellation_event,
     )
     if exit_code != 0:
         click.echo(f"commercial cutting exited with code {exit_code}.", err=True)
@@ -258,5 +301,9 @@ def _print_stream_urls(log_level: str, stream) -> None:
     _info(log_level, f"Recording HLS URL: {stream.url}")
 
 
+def _launched_without_arguments() -> bool:
+    return len(sys.argv) == 1
+
+
 if __name__ == "__main__":
     main()

{tv_recorder-0.0.0.dev3 → tv_recorder-0.0.0.dev4}/src/tv_recorder/comskip.py

@@ -5,12 +5,15 @@ import re
 import shutil
 import subprocess
 import sys
+import threading
 import urllib.request
 import zipfile
 from collections.abc import Callable
 from dataclasses import dataclass
 from pathlib import Path
 
+from tv_recorder.recorder import _ActivityIndicator
+
 
 COMSKIP_VERSION = "0.82.012"
 COMSKIP_WINDOWS_URL = "https://www.kaashoek.com/files/comskip82_012.zip"
@@ -70,10 +73,21 @@ def build_comskip_plan(
     )
 
 
-def run_comskip(plan: ComskipPlan, *, debug: bool = False) -> int:
+def run_comskip(
+    plan: ComskipPlan,
+    *,
+    debug: bool = False,
+    activity_callback: Callable[[str], None] | None = None,
+    cancellation_event: threading.Event | None = None,
+) -> int:
     plan.ini_path.write_text(_build_ini(plan.options), encoding="utf-8")
-    output = None if debug else subprocess.DEVNULL
-    completed = subprocess.run(plan.command, stdout=output, stderr=output)
+    completed = _run_command(
+        plan.command,
+        debug=debug,
+        activity_callback=activity_callback,
+        activity_label="comskip activity",
+        cancellation_event=cancellation_event,
+    )
     if not plan.edl_path.exists():
         if completed.returncode != 0:
             return completed.returncode
@@ -99,7 +113,14 @@ def _build_ini(options: dict) -> str:
     return "".join(f"{key}={value}\n" for key, value in settings.items())
 
 
-def cut_commercials(plan: ComskipPlan, *, ffmpeg_path: str, debug: bool = False) -> int:
+def cut_commercials(
+    plan: ComskipPlan,
+    *,
+    ffmpeg_path: str,
+    debug: bool = False,
+    activity_callback: Callable[[str], None] | None = None,
+    cancellation_event: threading.Event | None = None,
+) -> int:
     cuts = _filter_cuts(_read_edl_cuts(plan.edl_path), plan.options)
     duration = _media_duration_seconds(ffmpeg_path, plan.recording_path) if cuts else None
     if cuts and duration is None:
@@ -113,6 +134,8 @@ def cut_commercials(plan: ComskipPlan, *, ffmpeg_path: str, debug: bool = False)
             plan.recording_path,
             plan.commercial_free_path,
             debug=debug,
+            activity_callback=activity_callback,
+            cancellation_event=cancellation_event,
         )
     if len(keep_intervals) == 1:
         start, end = keep_intervals[0]
@@ -123,11 +146,12 @@ def cut_commercials(plan: ComskipPlan, *, ffmpeg_path: str, debug: bool = False)
             start=start,
             end=end,
             debug=debug,
+            activity_callback=activity_callback,
+            cancellation_event=cancellation_event,
         )
 
     temp_dir = plan.recording_path.with_name(f".{plan.recording_path.stem}.comskip-parts")
     temp_dir.mkdir(parents=True, exist_ok=True)
-    output = None if debug else subprocess.DEVNULL
     segment_paths: list[Path] = []
     try:
         for index, (start, end) in enumerate(keep_intervals, start=1):
@@ -156,7 +180,13 @@ def cut_commercials(plan: ComskipPlan, *, ffmpeg_path: str, debug: bool = False)
                 "make_zero",
                 str(segment_path),
             ])
-            completed = subprocess.run(command, stdout=output, stderr=output)
+            completed = _run_command(
+                command,
+                debug=debug,
+                activity_callback=activity_callback,
+                activity_label="comskip activity",
+                cancellation_event=cancellation_event,
+            )
             if completed.returncode != 0:
                 return completed.returncode
             segment_paths.append(segment_path)
@@ -184,7 +214,13 @@ def cut_commercials(plan: ComskipPlan, *, ffmpeg_path: str, debug: bool = False)
             "+faststart",
             str(plan.commercial_free_path),
         ]
-        completed = subprocess.run(command, stdout=output, stderr=output)
+        completed = _run_command(
+            command,
+            debug=debug,
+            activity_callback=activity_callback,
+            activity_label="comskip activity",
+            cancellation_event=cancellation_event,
+        )
         return completed.returncode
     finally:
         shutil.rmtree(temp_dir, ignore_errors=True)
@@ -261,8 +297,15 @@ def _keep_intervals(cuts: list[tuple[float, float]], duration: float | None) ->
     ]
 
 
-def _remux_to_mp4(ffmpeg_path: str, input_path: Path, output_path: Path, *, debug: bool) -> int:
-    output = None if debug else subprocess.DEVNULL
+def _remux_to_mp4(
+    ffmpeg_path: str,
+    input_path: Path,
+    output_path: Path,
+    *,
+    debug: bool,
+    activity_callback: Callable[[str], None] | None = None,
+    cancellation_event: threading.Event | None = None,
+) -> int:
     command = [
         ffmpeg_path,
         "-y",
@@ -281,7 +324,13 @@ def _remux_to_mp4(ffmpeg_path: str, input_path: Path, output_path: Path, *, debu
         "+faststart",
         str(output_path),
     ]
-    completed = subprocess.run(command, stdout=output, stderr=output)
+    completed = _run_command(
+        command,
+        debug=debug,
+        activity_callback=activity_callback,
+        activity_label="comskip activity",
+        cancellation_event=cancellation_event,
+    )
     return completed.returncode
 
 
@@ -293,8 +342,9 @@ def _copy_interval_to_mp4(
     start: float,
     end: float | None,
     debug: bool,
+    activity_callback: Callable[[str], None] | None = None,
+    cancellation_event: threading.Event | None = None,
 ) -> int:
-    output = None if debug else subprocess.DEVNULL
     command = [
         ffmpeg_path,
         "-y",
@@ -321,10 +371,51 @@ def _copy_interval_to_mp4(
         "+faststart",
         str(output_path),
     ])
-    completed = subprocess.run(command, stdout=output, stderr=output)
+    completed = _run_command(
+        command,
+        debug=debug,
+        activity_callback=activity_callback,
+        activity_label="comskip activity",
+        cancellation_event=cancellation_event,
+    )
     return completed.returncode
 
 
+def _run_command(
+    command: list[str],
+    *,
+    debug: bool,
+    activity_callback: Callable[[str], None] | None,
+    activity_label: str,
+    cancellation_event: threading.Event | None = None,
+) -> subprocess.CompletedProcess:
+    output = None if debug else subprocess.DEVNULL
+    if activity_callback is None and cancellation_event is None:
+        return subprocess.run(command, stdout=output, stderr=output)
+
+    process = subprocess.Popen(
+        command,
+        stdout=subprocess.PIPE if activity_callback else output,
+        stderr=subprocess.STDOUT,
+    )
+    activity = _ActivityIndicator(activity_label, callback=activity_callback)
+    activity.start(process.stdout if activity_callback else None)
+    try:
+        while True:
+            if cancellation_event and cancellation_event.is_set():
+                process.terminate()
+                return_code = process.wait()
+                return subprocess.CompletedProcess(command, return_code)
+            try:
+                return_code = process.wait(timeout=0.2)
+                break
+            except subprocess.TimeoutExpired:
+                continue
+    finally:
+        activity.stop()
+    return subprocess.CompletedProcess(command, return_code)
+
+
 def _media_duration_seconds(ffmpeg_path: str, path: Path) -> float | None:
     completed = subprocess.run(
         [ffmpeg_path, "-hide_banner", "-i", str(path)],

{tv_recorder-0.0.0.dev3 → tv_recorder-0.0.0.dev4}/src/tv_recorder/defaults.yaml

@@ -1,3 +1,4 @@
+default: radio-canada.ca
 sources:
   radio-canada.ca:
     display_name: ICI Radio-Canada Tele

tv_recorder-0.0.0.dev4/src/tv_recorder/gui.py

@@ -0,0 +1,376 @@
+from __future__ import annotations
+
+import contextlib
+import queue
+import threading
+import tkinter as tk
+from datetime import datetime
+from pathlib import Path
+from tkinter import filedialog
+from tkinter import messagebox
+from tkinter import ttk
+from tkinter.scrolledtext import ScrolledText
+
+from tv_recorder.cli import run_existing_comskip, run_record_command
+from tv_recorder.config import load_config
+
+
+_DONE_MESSAGE = "__TV_RECORDER_DONE__"
+_ACTIVITY_PREFIX = "__TV_RECORDER_ACTIVITY__"
+_COMSKIP_ACTIVITY_PREFIX = "__TV_RECORDER_COMSKIP_ACTIVITY__"
+
+
+class _QueueWriter:
+    def __init__(self, log_queue: queue.Queue[str]) -> None:
+        self._log_queue = log_queue
+        self._buffer = ""
+
+    def write(self, text: str) -> int:
+        self._buffer += text
+        while "\n" in self._buffer:
+            line, self._buffer = self._buffer.split("\n", 1)
+            self._log_queue.put(line)
+        return len(text)
+
+    def flush(self) -> None:
+        if self._buffer:
+            self._log_queue.put(self._buffer)
+            self._buffer = ""
+
+    def isatty(self) -> bool:
+        return False
+
+
+class RecorderApp:
+    def __init__(self, root: tk.Tk) -> None:
+        self.root = root
+        self.root.title("tv-recorder")
+        self.root.geometry("920x680")
+        self.root.minsize(760, 560)
+
+        self.log_queue: queue.Queue[str] = queue.Queue()
+        self.worker: threading.Thread | None = None
+        self.cancellation_event = threading.Event()
+        self.config: dict = {}
+
+        self.source = tk.StringVar()
+        now = datetime.now()
+        self.start_now = tk.BooleanVar(value=True)
+        self.start_date = tk.StringVar(value=now.strftime("%Y-%m-%d"))
+        self.start_hour = tk.IntVar(value=now.hour)
+        self.start_minute = tk.IntVar(value=now.minute)
+        self.duration = tk.StringVar(value="30m")
+        self.output_dir = tk.StringVar(value=str(Path.cwd()))
+        self.timeout_ms = tk.IntVar(value=45_000)
+        self.comskip = tk.BooleanVar(value=False)
+        self.comskip_file = tk.StringVar()
+        self.ffmpeg_activity = tk.StringVar(value="ffmpeg: idle")
+        self.comskip_activity = tk.StringVar(value="comskip: idle")
+
+        self._build_ui()
+        self._load_config()
+        self._poll_logs()
+
+    def _build_ui(self) -> None:
+        self.root.columnconfigure(0, weight=1)
+        self.root.rowconfigure(0, weight=1)
+
+        panes = ttk.PanedWindow(self.root, orient=tk.VERTICAL)
+        panes.grid(row=0, column=0, sticky="nsew", padx=12, pady=12)
+
+        options = ttk.Frame(panes, padding=0)
+        options.columnconfigure(0, weight=1)
+        panes.add(options, weight=0)
+
+        notebook = ttk.Notebook(options)
+        notebook.grid(row=0, column=0, sticky="ew")
+
+        record_tab = ttk.Frame(notebook, padding=12)
+        record_tab.columnconfigure(1, weight=1)
+        notebook.add(record_tab, text="Recording")
+
+        ttk.Label(record_tab, text="Channel").grid(row=0, column=0, sticky="w", pady=4)
+        self.source_combo = ttk.Combobox(record_tab, textvariable=self.source, state="readonly")
+        self.source_combo.grid(row=0, column=1, sticky="ew", pady=4)
+
+        ttk.Label(record_tab, text="Start").grid(row=1, column=0, sticky="w", pady=4)
+        start_frame = ttk.Frame(record_tab)
+        start_frame.grid(row=1, column=1, sticky="w", pady=4)
+        self.start_now_check = ttk.Checkbutton(
+            start_frame,
+            text="Now",
+            variable=self.start_now,
+            command=self._sync_start_controls,
+        )
+        self.start_now_check.grid(row=0, column=0, padx=(0, 12))
+        self.start_date_entry = ttk.Entry(start_frame, textvariable=self.start_date, width=12)
+        self.start_date_entry.grid(row=0, column=1, padx=(0, 8))
+        self.start_hour_spin = ttk.Spinbox(
+            start_frame,
+            textvariable=self.start_hour,
+            from_=0,
+            to=23,
+            width=3,
+            format="%02.0f",
+        )
+        self.start_hour_spin.grid(row=0, column=2)
+        ttk.Label(start_frame, text=":").grid(row=0, column=3, padx=2)
+        self.start_minute_spin = ttk.Spinbox(
+            start_frame,
+            textvariable=self.start_minute,
+            from_=0,
+            to=59,
+            width=3,
+            format="%02.0f",
+        )
+        self.start_minute_spin.grid(row=0, column=4)
+
+        ttk.Label(record_tab, text="Duration").grid(row=2, column=0, sticky="w", pady=4)
+        ttk.Entry(record_tab, textvariable=self.duration).grid(row=2, column=1, sticky="ew", pady=4)
+
+        ttk.Label(record_tab, text="Output folder").grid(row=3, column=0, sticky="w", pady=4)
+        ttk.Entry(record_tab, textvariable=self.output_dir).grid(row=3, column=1, sticky="ew", pady=4)
+        ttk.Button(record_tab, text="Browse", command=self._browse_output_dir).grid(row=3, column=2, padx=(8, 0))
+
+        ttk.Label(record_tab, text="Timeout Playwright").grid(row=4, column=0, sticky="w", pady=4)
+        ttk.Spinbox(record_tab, textvariable=self.timeout_ms, from_=1_000, to=300_000, increment=1_000).grid(
+            row=4,
+            column=1,
+            sticky="w",
+            pady=4,
+        )
+
+        checks = ttk.Frame(record_tab)
+        checks.grid(row=5, column=1, sticky="w", pady=(8, 4))
+        ttk.Checkbutton(checks, text="Comskip", variable=self.comskip).grid(row=0, column=0)
+
+        actions = ttk.Frame(record_tab)
+        actions.grid(row=6, column=1, sticky="e", pady=(10, 0))
+        self.record_button = ttk.Button(actions, text="Start", command=self._start_recording)
+        self.record_button.grid(row=0, column=0)
+        self.stop_record_button = ttk.Button(actions, text="Stop", command=self._request_stop, state="disabled")
+        self.stop_record_button.grid(row=0, column=1, padx=(8, 0))
+
+        comskip_tab = ttk.Frame(notebook, padding=12)
+        comskip_tab.columnconfigure(1, weight=1)
+        notebook.add(comskip_tab, text="Comskip")
+
+        ttk.Label(comskip_tab, text="File").grid(row=0, column=0, sticky="w", pady=4)
+        ttk.Entry(comskip_tab, textvariable=self.comskip_file).grid(row=0, column=1, sticky="ew", pady=4)
+        ttk.Button(comskip_tab, text="Browse", command=self._browse_comskip_file).grid(row=0, column=2, padx=(8, 0))
+        self.comskip_button = ttk.Button(comskip_tab, text="Run Comskip", command=self._start_existing_comskip)
+        self.comskip_button.grid(row=1, column=1, sticky="e", pady=(10, 0))
+        self.stop_comskip_button = ttk.Button(comskip_tab, text="Stop", command=self._request_stop, state="disabled")
+        self.stop_comskip_button.grid(row=1, column=2, sticky="e", padx=(8, 0), pady=(10, 0))
+
+        log_frame = ttk.Frame(panes)
+        log_frame.columnconfigure(0, weight=1)
+        log_frame.rowconfigure(1, weight=1)
+        panes.add(log_frame, weight=1)
+
+        log_header = ttk.Frame(log_frame)
+        log_header.grid(row=0, column=0, sticky="ew", pady=(10, 4))
+        log_header.columnconfigure(0, weight=1)
+        ttk.Label(log_header, text="Logs").grid(row=0, column=0, sticky="w")
+        ttk.Label(log_header, textvariable=self.ffmpeg_activity, width=18).grid(row=0, column=1, padx=(0, 12))
+        ttk.Label(log_header, textvariable=self.comskip_activity, width=20).grid(row=0, column=2, padx=(0, 12))
+        ttk.Button(log_header, text="Clear", command=self._clear_logs).grid(row=0, column=3)
+
+        self.logs = ScrolledText(log_frame, height=16, wrap=tk.WORD, state="disabled")
+        self.logs.grid(row=1, column=0, sticky="nsew")
+        self._sync_start_controls()
+
+    def _browse_output_dir(self) -> None:
+        path = filedialog.askdirectory(title="Choose the output folder")
+        if path:
+            self.output_dir.set(path)
+
+    def _browse_comskip_file(self) -> None:
+        path = filedialog.askopenfilename(
+            title="Choose a recording",
+            filetypes=[("Videos", "*.mp4 *.mkv *.ts"), ("All files", "*.*")],
+        )
+        if path:
+            self.comskip_file.set(path)
+
+    def _load_config(self) -> None:
+        try:
+            self.config = load_config()
+            sources = self.config.get("sources") or {}
+            values = [
+                f"{key} - {sources[key].get('display_name') or key}"
+                for key in sorted(sources)
+            ]
+            self.source_combo["values"] = values
+            if values and not self.source.get():
+                self.source.set(_default_source_value(self.config, values))
+            self._log(f"Loaded configuration: {len(values)} channel(s).")
+        except Exception as exc:
+            messagebox.showerror("Configuration", str(exc))
+            self._log(f"Configuration error: {exc}")
+
+    def _start_recording(self) -> None:
+        if self.worker and self.worker.is_alive():
+            return
+        source_key = self._selected_source_key()
+        if not source_key:
+            messagebox.showerror("Recording", "Choose a channel.")
+            return
+        self.cancellation_event = threading.Event()
+        self._set_running(True)
+        self.ffmpeg_activity.set("ffmpeg: waiting")
+        self.comskip_activity.set("comskip: idle")
+        self._log("Starting recording.")
+        self.worker = threading.Thread(
+            target=self._recording_worker,
+            args=(source_key,),
+            daemon=True,
+        )
+        self.worker.start()
+
+    def _start_existing_comskip(self) -> None:
+        if self.worker and self.worker.is_alive():
+            return
+        if not self.comskip_file.get().strip():
+            messagebox.showerror("Comskip", "Choose a recording file.")
+            return
+        self.cancellation_event = threading.Event()
+        self._set_running(True)
+        self.ffmpeg_activity.set("ffmpeg: idle")
+        self.comskip_activity.set("comskip: waiting")
+        self._log("Starting Comskip.")
+        self.worker = threading.Thread(target=self._existing_comskip_worker, daemon=True)
+        self.worker.start()
+
+    def _recording_worker(self, source_key: str) -> None:
+        writer = _QueueWriter(self.log_queue)
+        try:
+            with contextlib.redirect_stdout(writer), contextlib.redirect_stderr(writer):
+                exit_code = run_record_command(
+                    self.config,
+                    source_key=source_key,
+                    start_value=self._start_value(),
+                    duration_value=self.duration.get(),
+                    output_dir=Path(self.output_dir.get()),
+                    headful=False,
+                    timeout_ms=int(self.timeout_ms.get()),
+                    ffmpeg_path="ffmpeg",
+                    comskip=self.comskip.get(),
+                    dry_run=False,
+                    log_level="info",
+                    activity_callback=self._queue_ffmpeg_activity,
+                    comskip_activity_callback=self._queue_comskip_activity,
+                    cancellation_event=self.cancellation_event,
+                )
+                print(f"Finished with exit code {exit_code}.")
+        except Exception as exc:
+            self.log_queue.put(f"Error: {exc}")
+        finally:
+            writer.flush()
+            self.log_queue.put(_DONE_MESSAGE)
+
+    def _existing_comskip_worker(self) -> None:
+        writer = _QueueWriter(self.log_queue)
+        try:
+            with contextlib.redirect_stdout(writer), contextlib.redirect_stderr(writer):
+                exit_code = run_existing_comskip(
+                    self.config,
+                    Path(self.comskip_file.get()),
+                    ffmpeg_path="ffmpeg",
+                    log_level="info",
+                    activity_callback=self._queue_comskip_activity,
+                    cancellation_event=self.cancellation_event,
+                )
+                print(f"Finished with exit code {exit_code}.")
+        except Exception as exc:
+            self.log_queue.put(f"Error: {exc}")
+        finally:
+            writer.flush()
+            self.log_queue.put(_DONE_MESSAGE)
+
+    def _selected_source_key(self) -> str:
+        value = self.source.get()
+        return value.split(" - ", 1)[0].strip()
+
+    def _start_value(self) -> str:
+        if self.start_now.get():
+            return "now"
+        date_text = self.start_date.get().strip()
+        hour = int(self.start_hour.get())
+        minute = int(self.start_minute.get())
+        return f"{date_text}T{hour:02d}:{minute:02d}:00"
+
+    def _sync_start_controls(self) -> None:
+        state = "disabled" if self.start_now.get() else "normal"
+        self.start_date_entry.configure(state=state)
+        self.start_hour_spin.configure(state=state)
+        self.start_minute_spin.configure(state=state)
+
+    def _poll_logs(self) -> None:
+        try:
+            while True:
+                message = self.log_queue.get_nowait()
+                if message == _DONE_MESSAGE:
+                    self._set_running(False)
+                    self.ffmpeg_activity.set("ffmpeg: idle")
+                    self.comskip_activity.set("comskip: idle")
+                elif message.startswith(_ACTIVITY_PREFIX):
+                    frame = message.removeprefix(_ACTIVITY_PREFIX)
+                    self.ffmpeg_activity.set(f"ffmpeg: {frame}")
+                elif message.startswith(_COMSKIP_ACTIVITY_PREFIX):
+                    frame = message.removeprefix(_COMSKIP_ACTIVITY_PREFIX)
+                    self.comskip_activity.set(f"comskip: {frame}")
+                else:
+                    self._log(message)
+        except queue.Empty:
+            pass
+        self.root.after(100, self._poll_logs)
+
+    def _log(self, message: str) -> None:
+        self.logs.configure(state="normal")
+        self.logs.insert(tk.END, message + "\n")
+        self.logs.see(tk.END)
+        self.logs.configure(state="disabled")
+
+    def _clear_logs(self) -> None:
+        self.logs.configure(state="normal")
+        self.logs.delete("1.0", tk.END)
+        self.logs.configure(state="disabled")
+
+    def _set_running(self, running: bool) -> None:
+        start_state = "disabled" if running else "normal"
+        stop_state = "normal" if running else "disabled"
+        self.record_button.configure(state=start_state)
+        self.comskip_button.configure(state=start_state)
+        self.stop_record_button.configure(state=stop_state)
+        self.stop_comskip_button.configure(state=stop_state)
+
+    def _request_stop(self) -> None:
+        if self.cancellation_event.is_set():
+            return
+        self.cancellation_event.set()
+        self.stop_record_button.configure(state="disabled")
+        self.stop_comskip_button.configure(state="disabled")
+        self._log("Stop requested.")
+
+    def _queue_ffmpeg_activity(self, frame: str) -> None:
+        self.log_queue.put(f"{_ACTIVITY_PREFIX}{frame}")
+
+    def _queue_comskip_activity(self, frame: str) -> None:
+        self.log_queue.put(f"{_COMSKIP_ACTIVITY_PREFIX}{frame}")
+
+
+def main() -> None:
+    root = tk.Tk()
+    RecorderApp(root)
+    root.mainloop()
+
+
+def _default_source_value(config: dict, values: list[str]) -> str:
+    default_key = config.get("default")
+    if isinstance(default_key, str):
+        prefix = f"{default_key} - "
+        match = next((value for value in values if value.startswith(prefix)), None)
+        if match:
+            return match
+    return values[0]

{tv_recorder-0.0.0.dev3 → tv_recorder-0.0.0.dev4}/src/tv_recorder/recorder.py

@@ -6,6 +6,7 @@ import subprocess
 import sys
 import threading
 import time
+from collections.abc import Callable
 from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
@@ -318,7 +319,13 @@ def _media_duration_seconds(ffmpeg: str, path: Path) -> float | None:
     )
 
 
-def run_recording(plan: RecordingPlan, *, debug: bool = False) -> int:
+def run_recording(
+    plan: RecordingPlan,
+    *,
+    debug: bool = False,
+    activity_callback: Callable[[str], None] | None = None,
+    cancellation_event: threading.Event | None = None,
+) -> int:
     plan.capture_path.parent.mkdir(parents=True, exist_ok=True)
     output = None if debug else subprocess.DEVNULL
     stderr = None if debug else subprocess.PIPE
@@ -328,24 +335,25 @@ def run_recording(plan: RecordingPlan, *, debug: bool = False) -> int:
         stdout=output,
         stderr=stderr,
     )
-    activity = _ActivityIndicator("ffmpeg activity")
+    activity = _ActivityIndicator("ffmpeg activity", callback=activity_callback)
     activity.start(process.stderr if not debug else None)
     try:
-        exit_code = process.wait(timeout=plan.duration_seconds + 60)
-    except subprocess.TimeoutExpired:
-        if process.stdin:
-            process.stdin.write(b"q\n")
-            process.stdin.flush()
-        try:
-            exit_code = process.wait(timeout=30)
-        except subprocess.TimeoutExpired:
-            process.terminate()
-            exit_code = process.wait()
+        deadline = time.monotonic() + plan.duration_seconds + 60
+        while True:
+            if cancellation_event and cancellation_event.is_set():
+                _stop_ffmpeg(process)
+                return 130
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                exit_code = _stop_ffmpeg(process)
+                break
+            try:
+                exit_code = process.wait(timeout=min(0.2, remaining))
+                break
+            except subprocess.TimeoutExpired:
+                continue
     except KeyboardInterrupt:
-        if process.stdin:
-            process.stdin.write(b"q\n")
-            process.stdin.flush()
-        exit_code = process.wait()
+        exit_code = _stop_ffmpeg(process)
     finally:
         activity.stop()
 
@@ -359,13 +367,51 @@ def run_recording(plan: RecordingPlan, *, debug: bool = False) -> int:
         plan.capture_path.replace(plan.output_path)
         return _validate_duration(plan)
 
-    final = subprocess.run(plan.final_command, stdout=output, stderr=output)
+    final = _run_cancellable_command(
+        plan.final_command,
+        stdout=output,
+        stderr=output,
+        cancellation_event=cancellation_event,
+    )
     if final.returncode == 0:
         plan.capture_path.unlink(missing_ok=True)
         return _validate_duration(plan)
     return final.returncode
 
 
+def _stop_ffmpeg(process: subprocess.Popen) -> int:
+    if process.stdin:
+        process.stdin.write(b"q\n")
+        process.stdin.flush()
+    try:
+        return process.wait(timeout=30)
+    except subprocess.TimeoutExpired:
+        process.terminate()
+        return process.wait()
+
+
+def _run_cancellable_command(
+    command: list[str],
+    *,
+    stdout,
+    stderr,
+    cancellation_event: threading.Event | None = None,
+) -> subprocess.CompletedProcess:
+    if cancellation_event is None:
+        return subprocess.run(command, stdout=stdout, stderr=stderr)
+
+    process = subprocess.Popen(command, stdout=stdout, stderr=stderr)
+    while True:
+        if cancellation_event.is_set():
+            process.terminate()
+            return subprocess.CompletedProcess(command, process.wait(), None, None)
+        try:
+            return_code = process.wait(timeout=0.2)
+            return subprocess.CompletedProcess(command, return_code, None, None)
+        except subprocess.TimeoutExpired:
+            continue
+
+
 def _validate_duration(plan: RecordingPlan) -> int:
     duration = _media_duration_seconds(plan.ffmpeg_path, plan.output_path)
     if duration is None:
@@ -381,8 +427,9 @@ def _validate_duration(plan: RecordingPlan) -> int:
 
 
 class _ActivityIndicator:
-    def __init__(self, label: str) -> None:
+    def __init__(self, label: str, *, callback: Callable[[str], None] | None = None) -> None:
         self.label = label
+        self.callback = callback
         self._enabled = sys.stderr.isatty()
         self._frames = "|/-\\"
         self._index = 0
@@ -410,7 +457,7 @@ class _ActivityIndicator:
             self._tick()
 
     def _tick(self) -> None:
-        if not self._enabled:
+        if not self._enabled and not self.callback:
             return
         now = time.monotonic()
         if now < self._next_update:
@@ -418,5 +465,8 @@ class _ActivityIndicator:
         self._next_update = now + 0.15
         frame = self._frames[self._index % len(self._frames)]
         self._index += 1
-        sys.stderr.write(f"\r{self.label} {frame}")
-        sys.stderr.flush()
+        if self.callback:
+            self.callback(frame)
+        if self._enabled:
+            sys.stderr.write(f"\r{self.label} {frame}")
+            sys.stderr.flush()

tv_recorder-0.0.0.dev4/tests/test_cli.py

@@ -0,0 +1,92 @@
+import threading
+from pathlib import Path
+from unittest.mock import patch
+
+from tv_recorder.cli import _source_key_from_recording
+from tv_recorder.cli import main
+from tv_recorder.cli import run_record_command
+from tv_recorder.recorder import _ActivityIndicator
+
+
+def test_source_key_from_recording_uses_filename_prefix() -> None:
+    config = {
+        "sources": {
+            "tvaplus.ca": {},
+            "radio-canada.ca": {},
+        }
+    }
+
+    assert (
+        _source_key_from_recording(
+            config,
+            Path("recordings/tvaplus.ca-20260529-190942.mp4"),
+        )
+        == "tvaplus.ca"
+    )
+
+
+def test_source_key_from_recording_uses_longest_match() -> None:
+    config = {
+        "sources": {
+            "globalnews": {},
+            "globalnews-national": {},
+        }
+    }
+
+    assert (
+        _source_key_from_recording(
+            config,
+            Path("recordings/globalnews-national-20260529-190942.mp4"),
+        )
+        == "globalnews-national"
+    )
+
+
+def test_help_shows_current_directory_as_default_output_dir() -> None:
+    from click.testing import CliRunner
+
+    result = CliRunner().invoke(main, ["--help"])
+
+    assert result.exit_code == 0
+    assert "current directory" in result.output
+
+
+def test_activity_indicator_calls_callback_when_stderr_is_not_tty() -> None:
+    frames = []
+    indicator = _ActivityIndicator("ffmpeg activity", callback=frames.append)
+
+    indicator._tick()
+
+    assert frames == ["|"]
+
+
+def test_record_command_honors_cancel_before_stream_detection() -> None:
+    cancelled = threading.Event()
+    cancelled.set()
+    config = {
+        "sources": {
+            "test": {
+                "display_name": "Test",
+                "start_url": "https://example.com",
+            },
+        },
+    }
+
+    with patch("tv_recorder.cli.find_stream") as find_stream:
+        exit_code = run_record_command(
+            config,
+            source_key="test",
+            start_value="now",
+            duration_value="30m",
+            output_dir=Path("recordings"),
+            headful=False,
+            timeout_ms=45_000,
+            ffmpeg_path="ffmpeg",
+            comskip=False,
+            dry_run=False,
+            log_level="info",
+            cancellation_event=cancelled,
+        )
+
+    assert exit_code == 130
+    find_stream.assert_not_called()

{tv_recorder-0.0.0.dev3 → tv_recorder-0.0.0.dev4}/tests/test_comskip.py

@@ -1,3 +1,4 @@
+from io import BytesIO
 from pathlib import Path
 import shutil
 from uuid import uuid4
@@ -68,6 +69,38 @@ def test_run_comskip_accepts_completed_processing_with_nonzero_exit() -> None:
         shutil.rmtree(work_dir, ignore_errors=True)
 
 
+def test_run_comskip_reports_activity_with_callback() -> None:
+    work_dir = Path("recordings") / f"tv-recorder-comskip-test-{uuid4().hex}"
+    work_dir.mkdir(parents=True)
+    try:
+        recording = work_dir / "show.mp4"
+        recording.write_bytes(b"video")
+        plan = ComskipPlan(
+            recording_path=recording,
+            edl_path=work_dir / "show.edl",
+            ini_path=work_dir / "show.comskip.ini",
+            commercial_free_path=work_dir / "show.commercial-free.mp4",
+            command=["comskip", str(recording)],
+            options={},
+        )
+        plan.edl_path.write_text("1.0\t2.0\t0\n", encoding="utf-8")
+        recording.with_suffix(".txt").write_text(
+            "FILE PROCESSING COMPLETE\n",
+            encoding="utf-8",
+        )
+        frames = []
+
+        with patch("tv_recorder.comskip.subprocess.Popen") as popen:
+            popen.return_value.stdout = BytesIO(b"activity")
+            popen.return_value.wait.return_value = 0
+
+            assert run_comskip(plan, activity_callback=frames.append) == 0
+
+        assert frames
+    finally:
+        shutil.rmtree(work_dir, ignore_errors=True)
+
+
 def test_read_edl_cuts() -> None:
     work_dir = Path("recordings") / f"tv-recorder-comskip-test-{uuid4().hex}"
     work_dir.mkdir(parents=True)

tv_recorder-0.0.0.dev4/tests/test_gui.py

@@ -0,0 +1,22 @@
+from tv_recorder.gui import _default_source_value
+
+
+def test_default_source_value_uses_config_default() -> None:
+    values = [
+        "abc-news-live - ABC News Live",
+        "radio-canada.ca - ICI Radio-Canada Tele",
+    ]
+
+    assert (
+        _default_source_value({"default": "radio-canada.ca"}, values)
+        == "radio-canada.ca - ICI Radio-Canada Tele"
+    )
+
+
+def test_default_source_value_falls_back_to_first_source() -> None:
+    values = [
+        "abc-news-live - ABC News Live",
+        "radio-canada.ca - ICI Radio-Canada Tele",
+    ]
+
+    assert _default_source_value({"default": "missing"}, values) == values[0]

tv_recorder-0.0.0.dev3/tests/test_cli.py

@@ -1,37 +0,0 @@
-from pathlib import Path
-
-from tv_recorder.cli import _source_key_from_recording
-
-
-def test_source_key_from_recording_uses_filename_prefix() -> None:
-    config = {
-        "sources": {
-            "tvaplus.ca": {},
-            "radio-canada.ca": {},
-        }
-    }
-
-    assert (
-        _source_key_from_recording(
-            config,
-            Path("recordings/tvaplus.ca-20260529-190942.mp4"),
-        )
-        == "tvaplus.ca"
-    )
-
-
-def test_source_key_from_recording_uses_longest_match() -> None:
-    config = {
-        "sources": {
-            "globalnews": {},
-            "globalnews-national": {},
-        }
-    }
-
-    assert (
-        _source_key_from_recording(
-            config,
-            Path("recordings/globalnews-national-20260529-190942.mp4"),
-        )
-        == "globalnews-national"
-    )