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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tv-recorder
-Version: 0.0.0.dev2
+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
@@ -41,6 +41,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Multimedia :: Video
 Classifier: Topic :: Utilities
 Requires-Python: >=3.11
+Requires-Dist: click>=8.1
 Requires-Dist: imageio-ffmpeg>=0.6.0
 Requires-Dist: playwright>=1.44
 Requires-Dist: pytimeparse2>=1.7.1
@@ -55,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
 ```
@@ -92,12 +109,32 @@ tv-recorder globalnews-montreal now 30m
 tv-recorder radio-canada.ca now 10m --headful
 tv-recorder radio-canada.ca now 10m --dry-run
 tv-recorder radio-canada.ca now 10m --debug
+tv-recorder radio-canada.ca now 10m --comskip
+tv-recorder comskip recordings\tvaplus.ca-20260529-190942.mp4
 ```
 
 `START` accepts `now` or a local ISO date. `DURATION` accepts values such as `90s`, `30m`, `2h`, or `01:30:00`.
 
 By default, the CLI runs at `--info` level and prints the effective recording URL or inputs. During recording, a small activity indicator moves when ffmpeg emits progress. Use `--debug` to show discovery details, step results, and ffmpeg output.
 
+## Commercial Marking
+
+Use `--comskip` to run Comskip after a successful recording and create a commercial-free MP4. The original recording is kept unchanged. Comskip writes sidecar files next to it, including an `.edl` file when commercials are detected:
+
+```powershell
+tv-recorder radio-canada.ca now 1h --comskip
+```
+
+Run the same post-processing on an existing recording:
+
+```powershell
+tv-recorder comskip recordings\tvaplus.ca-20260529-190942.mp4
+```
+
+The channel settings are selected from the file name prefix, such as `tvaplus.ca-...mp4`.
+
+On Windows, Comskip is downloaded automatically on first use if `comskip.exe` is not already available. It is installed inside the active Python environment under `share\tv-recorder\comskip\`, which keeps a `pipx` installation self-contained.
+
 ## Configuration YAML
 
 The package includes a default configuration. To replace it, provide your own YAML file:
@@ -115,6 +152,7 @@ Each source can define:
 - `stream_response_json_keys`: JSON keys whose values should be treated as stream URLs.
 - `stream_url_reject_patterns`: stream URL patterns to ignore.
 - `recording`: video/audio track selection.
+- `comskip`: commercial marking and cutting settings.
 - `steps`: browser interaction recipe before stream detection.
 - `output_extension`: output file extension.
 - `user_agent`: optional user-agent for browser and recorder requests.

{tv_recorder-0.0.0.dev2 → 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
 ```
@@ -39,12 +55,32 @@ tv-recorder globalnews-montreal now 30m
 tv-recorder radio-canada.ca now 10m --headful
 tv-recorder radio-canada.ca now 10m --dry-run
 tv-recorder radio-canada.ca now 10m --debug
+tv-recorder radio-canada.ca now 10m --comskip
+tv-recorder comskip recordings\tvaplus.ca-20260529-190942.mp4
 ```
 
 `START` accepts `now` or a local ISO date. `DURATION` accepts values such as `90s`, `30m`, `2h`, or `01:30:00`.
 
 By default, the CLI runs at `--info` level and prints the effective recording URL or inputs. During recording, a small activity indicator moves when ffmpeg emits progress. Use `--debug` to show discovery details, step results, and ffmpeg output.
 
+## Commercial Marking
+
+Use `--comskip` to run Comskip after a successful recording and create a commercial-free MP4. The original recording is kept unchanged. Comskip writes sidecar files next to it, including an `.edl` file when commercials are detected:
+
+```powershell
+tv-recorder radio-canada.ca now 1h --comskip
+```
+
+Run the same post-processing on an existing recording:
+
+```powershell
+tv-recorder comskip recordings\tvaplus.ca-20260529-190942.mp4
+```
+
+The channel settings are selected from the file name prefix, such as `tvaplus.ca-...mp4`.
+
+On Windows, Comskip is downloaded automatically on first use if `comskip.exe` is not already available. It is installed inside the active Python environment under `share\tv-recorder\comskip\`, which keeps a `pipx` installation self-contained.
+
 ## Configuration YAML
 
 The package includes a default configuration. To replace it, provide your own YAML file:
@@ -62,6 +98,7 @@ Each source can define:
 - `stream_response_json_keys`: JSON keys whose values should be treated as stream URLs.
 - `stream_url_reject_patterns`: stream URL patterns to ignore.
 - `recording`: video/audio track selection.
+- `comskip`: commercial marking and cutting settings.
 - `steps`: browser interaction recipe before stream detection.
 - `output_extension`: output file extension.
 - `user_agent`: optional user-agent for browser and recorder requests.

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

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["hatchling>=1.24"]
+requires = ["hatchling>=1.24", "hatch-requirements-txt>=0.4.1"]
 build-backend = "hatchling.build"
 
 [project]
 name = "tv-recorder"
-version = "0.0.0.dev2"
+version = "0.0.0.dev4"
 description = "Command-line recorder for public live TV streams."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -26,12 +26,7 @@ classifiers = [
   "Topic :: Multimedia :: Video",
   "Topic :: Utilities",
 ]
-dependencies = [
-  "imageio-ffmpeg>=0.6.0",
-  "playwright>=1.44",
-  "pytimeparse2>=1.7.1",
-  "PyYAML>=6.0.1",
-]
+dynamic = ["dependencies"]
 
 [project.optional-dependencies]
 dev = [
@@ -54,5 +49,8 @@ packages = ["src/tv_recorder"]
 [tool.hatch.build.targets.wheel.force-include]
 "src/tv_recorder/defaults.yaml" = "tv_recorder/defaults.yaml"
 
+[tool.hatch.metadata.hooks.requirements_txt]
+files = ["requirements.txt"]
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]

tv_recorder-0.0.0.dev4/requirements.txt

@@ -0,0 +1,5 @@
+click>=8.1
+imageio-ffmpeg>=0.6.0
+playwright>=1.44
+pytimeparse2>=1.7.1
+PyYAML>=6.0.1

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

@@ -0,0 +1,309 @@
+from __future__ import annotations
+
+import shlex
+import sys
+import threading
+import time
+from collections.abc import Callable
+from pathlib import Path
+
+import click
+
+from tv_recorder import recorder
+from tv_recorder.comskip import build_comskip_plan, cut_commercials, run_comskip
+from tv_recorder.config import get_source, load_config
+from tv_recorder.duration import parse_duration, parse_start, seconds_until
+from tv_recorder.recorder import build_ffmpeg_plan, build_output_path, run_recording
+from tv_recorder.stream_finder import find_stream
+
+
+@click.command(context_settings={"help_option_names": ["-h", "--help"]})
+@click.argument("source", required=False)
+@click.argument("start", required=False)
+@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.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.")
+@click.option("--comskip", is_flag=True, help="Run Comskip after recording and create a commercial-free MP4.")
+@click.option("--dry-run", is_flag=True, help="Detect the stream and print the ffmpeg command.")
+@click.option("--info", "log_level", flag_value="info", default="info", help="Show normal progress and selected HLS URLs.")
+@click.option("--debug", "log_level", flag_value="debug", help="Show discovery steps and ffmpeg output.")
+def main(
+    source: str | None,
+    start: str | None,
+    duration: str | None,
+    config_path: Path | None,
+    list_channels: bool,
+    output_dir: Path,
+    headful: bool,
+    timeout_ms: int,
+    ffmpeg_path: str,
+    comskip: bool,
+    dry_run: bool,
+    log_level: str,
+) -> 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)
+            return
+
+        if source == "comskip":
+            if start is None or duration is not None:
+                raise click.UsageError("comskip requires exactly one recording file path")
+            exit_code = run_existing_comskip(
+                config,
+                Path(start),
+                ffmpeg_path=ffmpeg_path,
+                log_level=log_level,
+            )
+            raise click.exceptions.Exit(exit_code)
+
+        if source is None or start is None or duration is None:
+            raise click.UsageError("source, start, and duration are required unless --list is used")
+
+        exit_code = run_record_command(
+            config,
+            source_key=source,
+            start_value=start,
+            duration_value=duration,
+            output_dir=output_dir,
+            headful=headful,
+            timeout_ms=timeout_ms,
+            ffmpeg_path=ffmpeg_path,
+            comskip=comskip,
+            dry_run=dry_run,
+            log_level=log_level,
+        )
+        raise click.exceptions.Exit(exit_code)
+    except click.exceptions.Exit:
+        raise
+    except click.ClickException:
+        raise
+    except Exception as exc:
+        click.echo(f"Error: {exc}", err=True)
+        raise click.exceptions.Exit(1)
+
+
+def run_record_command(
+    config: dict,
+    *,
+    source_key: str,
+    start_value: str,
+    duration_value: str,
+    output_dir: Path,
+    headful: bool,
+    timeout_ms: int,
+    ffmpeg_path: str,
+    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)
+    duration_seconds = parse_duration(duration_value)
+    delay = seconds_until(start)
+
+    if delay > 0:
+        _info(log_level, f"Waiting until {start.isoformat()} ({int(delay)} s).")
+        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(
+        source,
+        headless=not headful,
+        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,
+        output_path,
+        duration_seconds,
+        ffmpeg_path=ffmpeg_path,
+        require_ffmpeg=not dry_run,
+        recording=source.recording,
+    )
+    _print_stream_urls(log_level, stream)
+
+    if dry_run:
+        click.echo("ffmpeg command:")
+        click.echo(shlex.join(plan.command))
+        if comskip:
+            comskip_plan = build_comskip_plan(
+                plan.output_path,
+                require_comskip=False,
+                auto_install=False,
+                options=source.comskip,
+            )
+            click.echo("comskip command:")
+            click.echo(shlex.join(comskip_plan.command))
+        return 0
+
+    _info(log_level, f"Recording to {plan.output_path}")
+    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
+
+    if comskip:
+        return run_comskip_pipeline(
+            config,
+            plan.output_path,
+            ffmpeg_path=plan.ffmpeg_path,
+            log_level=log_level,
+            activity_callback=comskip_activity_callback,
+            cancellation_event=cancellation_event,
+        )
+
+    return 0
+
+
+def list_sources(config: dict) -> None:
+    sources = config.get("sources") or {}
+    if not sources:
+        click.echo("No sources available.")
+        return
+
+    width = max(len(key) for key in sources)
+    for key in sorted(sources):
+        display_name = sources[key].get("display_name") or key
+        click.echo(f"{key.ljust(width)}  {display_name}")
+
+
+def run_existing_comskip(
+    config: dict,
+    recording_path: Path,
+    *,
+    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)
+    resolved_ffmpeg = recorder._resolve_ffmpeg(ffmpeg_path, require_ffmpeg=True)
+    return run_comskip_pipeline(
+        config,
+        recording_path,
+        ffmpeg_path=resolved_ffmpeg,
+        log_level=log_level,
+        activity_callback=activity_callback,
+        cancellation_event=cancellation_event,
+    )
+
+
+def run_comskip_pipeline(
+    config: dict,
+    recording_path: Path,
+    *,
+    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
+    if source:
+        _info(log_level, f"Using Comskip settings for {source.display_name}.")
+    else:
+        _info(log_level, "Using default Comskip settings.")
+
+    comskip_plan = build_comskip_plan(
+        recording_path,
+        auto_install=True,
+        options=source.comskip if source else None,
+        log=lambda message: _info(log_level, message),
+    )
+    _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",
+        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
+
+    _info(log_level, f"Comskip EDL: {comskip_plan.edl_path}")
+    _info(log_level, f"Writing commercial-free MP4 to {comskip_plan.commercial_free_path}")
+    exit_code = cut_commercials(
+        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)
+        return exit_code
+    _info(log_level, f"Commercial-free MP4: {comskip_plan.commercial_free_path}")
+    return 0
+
+
+def _source_key_from_recording(config: dict, recording_path: Path) -> str | None:
+    sources = config.get("sources") or {}
+    name = recording_path.name
+    matches = [key for key in sources if name.startswith(f"{key}-")]
+    if not matches:
+        return None
+    return max(matches, key=len)
+
+
+def _info(log_level: str, message: str) -> None:
+    if log_level in {"info", "debug"}:
+        click.echo(message)
+
+
+def _debug(log_level: str, message: str) -> None:
+    if log_level == "debug":
+        click.echo(f"DEBUG {message}")
+
+
+def _print_stream_urls(log_level: str, stream) -> None:
+    discovered = stream.discovered_url or stream.url
+    _debug(log_level, f"Discovered HLS URL: {discovered}")
+    if stream.input_urls:
+        for index, input_url in enumerate(stream.input_urls, start=1):
+            _info(log_level, f"Recording HLS input {index}: {input_url}")
+        return
+    _info(log_level, f"Recording HLS URL: {stream.url}")
+
+
+def _launched_without_arguments() -> bool:
+    return len(sys.argv) == 1
+
+
+if __name__ == "__main__":
+    main()