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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tv-recorder
-Version: 0.0.0.dev2
+Version: 0.0.0.dev3
 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
@@ -92,12 +93,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 +136,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.dev3}/README.md

@@ -39,12 +39,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 +82,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.dev3}/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.dev3"
 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.dev3/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.dev3/src/tv_recorder/cli.py

@@ -0,0 +1,262 @@
+from __future__ import annotations
+
+import shlex
+import time
+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("recordings"), show_default=True, 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:
+        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,
+) -> 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).")
+        time.sleep(delay)
+
+    _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),
+    )
+    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")
+    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,
+        )
+
+    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,
+) -> 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,
+    )
+
+
+def run_comskip_pipeline(
+    config: dict,
+    recording_path: Path,
+    *,
+    ffmpeg_path: str,
+    log_level: str,
+) -> 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")
+    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",
+    )
+    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}")
+
+
+if __name__ == "__main__":
+    main()

tv_recorder-0.0.0.dev3/src/tv_recorder/comskip.py

@@ -0,0 +1,446 @@
+from __future__ import annotations
+
+import platform
+import re
+import shutil
+import subprocess
+import sys
+import urllib.request
+import zipfile
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+
+
+COMSKIP_VERSION = "0.82.012"
+COMSKIP_WINDOWS_URL = "https://www.kaashoek.com/files/comskip82_012.zip"
+COMSKIP_WINDOWS_SHA256: str | None = None
+
+DEFAULT_INI = {
+    "output_edl": 1,
+    "output_txt": 1,
+    "live_tv": 1,
+}
+MIN_KEEP_INTERVAL_SECONDS = 1.0
+
+
+@dataclass(frozen=True)
+class ComskipPlan:
+    recording_path: Path
+    edl_path: Path
+    ini_path: Path
+    commercial_free_path: Path
+    command: list[str]
+    options: dict
+
+
+def build_comskip_plan(
+    recording_path: Path,
+    *,
+    comskip_path: str = "comskip",
+    require_comskip: bool = True,
+    auto_install: bool = False,
+    options: dict | None = None,
+    log: Callable[[str], None] | None = None,
+) -> ComskipPlan:
+    comskip = _resolve_comskip(
+        comskip_path,
+        require_comskip=require_comskip,
+        auto_install=auto_install,
+        log=log,
+    )
+    ini_path = recording_path.with_suffix(".comskip.ini")
+    edl_path = recording_path.with_suffix(".edl")
+    commercial_free_path = recording_path.with_name(
+        f"{recording_path.stem}.commercial-free.mp4"
+    )
+    command = [
+        comskip,
+        f"--ini={ini_path}",
+        f"--output={recording_path.parent}",
+        str(recording_path),
+    ]
+    return ComskipPlan(
+        recording_path=recording_path,
+        edl_path=edl_path,
+        ini_path=ini_path,
+        commercial_free_path=commercial_free_path,
+        command=command,
+        options=options or {},
+    )
+
+
+def run_comskip(plan: ComskipPlan, *, debug: bool = False) -> 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)
+    if not plan.edl_path.exists():
+        if completed.returncode != 0:
+            return completed.returncode
+        print(f"Comskip completed, but no EDL file was created at {plan.edl_path}.")
+        return 1
+    if _processing_completed(plan):
+        return 0
+    if completed.returncode != 0:
+        return completed.returncode
+    return 0
+
+
+def _processing_completed(plan: ComskipPlan) -> bool:
+    txt_path = plan.recording_path.with_suffix(".txt")
+    if not txt_path.exists():
+        return False
+    content = txt_path.read_text(encoding="utf-8", errors="replace")
+    return "FILE PROCESSING COMPLETE" in content
+
+
+def _build_ini(options: dict) -> str:
+    settings = {**DEFAULT_INI, **(options.get("ini") or {})}
+    return "".join(f"{key}={value}\n" for key, value in settings.items())
+
+
+def cut_commercials(plan: ComskipPlan, *, ffmpeg_path: str, debug: bool = False) -> 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:
+        print(f"Could not determine media duration for {plan.recording_path}.")
+        return 1
+
+    keep_intervals = _keep_intervals(cuts, duration)
+    if len(keep_intervals) == 1 and keep_intervals[0][0] == 0 and keep_intervals[0][1] is None:
+        return _remux_to_mp4(
+            ffmpeg_path,
+            plan.recording_path,
+            plan.commercial_free_path,
+            debug=debug,
+        )
+    if len(keep_intervals) == 1:
+        start, end = keep_intervals[0]
+        return _copy_interval_to_mp4(
+            ffmpeg_path,
+            plan.recording_path,
+            plan.commercial_free_path,
+            start=start,
+            end=end,
+            debug=debug,
+        )
+
+    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):
+            segment_path = temp_dir / f"part-{index:04d}.mp4"
+            command = [
+                ffmpeg_path,
+                "-y",
+                "-hide_banner",
+                "-loglevel",
+                "info",
+                "-ss",
+                _format_seconds(start),
+                "-i",
+                str(plan.recording_path),
+            ]
+            if end is not None:
+                command.extend(["-t", _format_seconds(end - start)])
+            command.extend([
+                "-map",
+                "0",
+                "-dn",
+                "-sn",
+                "-c",
+                "copy",
+                "-avoid_negative_ts",
+                "make_zero",
+                str(segment_path),
+            ])
+            completed = subprocess.run(command, stdout=output, stderr=output)
+            if completed.returncode != 0:
+                return completed.returncode
+            segment_paths.append(segment_path)
+
+        concat_path = temp_dir / "concat.txt"
+        concat_path.write_text(
+            "".join(f"file '{_concat_path(path)}'\n" for path in segment_paths),
+            encoding="utf-8",
+        )
+        command = [
+            ffmpeg_path,
+            "-y",
+            "-hide_banner",
+            "-loglevel",
+            "info",
+            "-f",
+            "concat",
+            "-safe",
+            "0",
+            "-i",
+            str(concat_path),
+            "-c",
+            "copy",
+            "-movflags",
+            "+faststart",
+            str(plan.commercial_free_path),
+        ]
+        completed = subprocess.run(command, stdout=output, stderr=output)
+        return completed.returncode
+    finally:
+        shutil.rmtree(temp_dir, ignore_errors=True)
+
+
+def _read_edl_cuts(path: Path) -> list[tuple[float, float]]:
+    if not path.exists():
+        return []
+    cuts = []
+    for line in path.read_text(encoding="utf-8", errors="replace").splitlines():
+        parts = line.split()
+        if len(parts) < 2:
+            continue
+        try:
+            start = float(parts[0])
+            end = float(parts[1])
+        except ValueError:
+            continue
+        if end > start:
+            cuts.append((start, end))
+    return sorted(cuts)
+
+
+def _filter_cuts(cuts: list[tuple[float, float]], options: dict) -> list[tuple[float, float]]:
+    if not cuts:
+        return []
+
+    min_segment_seconds = float(options.get("min_segment_seconds") or 0)
+    min_break_seconds = float(options.get("min_break_seconds") or 0)
+    gap_tolerance_seconds = float(options.get("break_gap_tolerance_seconds") or 0)
+
+    filtered = [
+        (start, end)
+        for start, end in cuts
+        if end - start >= min_segment_seconds
+    ]
+    if not filtered or not min_break_seconds:
+        return filtered
+
+    breaks: list[list[tuple[float, float]]] = []
+    for cut in filtered:
+        if not breaks or cut[0] - breaks[-1][-1][1] > gap_tolerance_seconds:
+            breaks.append([cut])
+        else:
+            breaks[-1].append(cut)
+
+    kept: list[tuple[float, float]] = []
+    for commercial_break in breaks:
+        break_duration = sum(end - start for start, end in commercial_break)
+        if break_duration >= min_break_seconds:
+            kept.extend(commercial_break)
+    return kept
+
+
+def _keep_intervals(cuts: list[tuple[float, float]], duration: float | None) -> list[tuple[float, float | None]]:
+    if not cuts:
+        return [(0, None)]
+
+    assert duration is not None
+    intervals: list[tuple[float, float | None]] = []
+    cursor = 0.0
+    for start, end in cuts:
+        start = max(0.0, min(start, duration))
+        end = max(0.0, min(end, duration))
+        if start > cursor:
+            intervals.append((cursor, start))
+        cursor = max(cursor, end)
+    if cursor < duration:
+        intervals.append((cursor, duration))
+    return [
+        (start, end)
+        for start, end in intervals
+        if end is None or end - start >= MIN_KEEP_INTERVAL_SECONDS
+    ]
+
+
+def _remux_to_mp4(ffmpeg_path: str, input_path: Path, output_path: Path, *, debug: bool) -> int:
+    output = None if debug else subprocess.DEVNULL
+    command = [
+        ffmpeg_path,
+        "-y",
+        "-hide_banner",
+        "-loglevel",
+        "info",
+        "-i",
+        str(input_path),
+        "-map",
+        "0",
+        "-dn",
+        "-sn",
+        "-c",
+        "copy",
+        "-movflags",
+        "+faststart",
+        str(output_path),
+    ]
+    completed = subprocess.run(command, stdout=output, stderr=output)
+    return completed.returncode
+
+
+def _copy_interval_to_mp4(
+    ffmpeg_path: str,
+    input_path: Path,
+    output_path: Path,
+    *,
+    start: float,
+    end: float | None,
+    debug: bool,
+) -> int:
+    output = None if debug else subprocess.DEVNULL
+    command = [
+        ffmpeg_path,
+        "-y",
+        "-hide_banner",
+        "-loglevel",
+        "info",
+        "-ss",
+        _format_seconds(start),
+        "-i",
+        str(input_path),
+    ]
+    if end is not None:
+        command.extend(["-t", _format_seconds(end - start)])
+    command.extend([
+        "-map",
+        "0",
+        "-dn",
+        "-sn",
+        "-c",
+        "copy",
+        "-avoid_negative_ts",
+        "make_zero",
+        "-movflags",
+        "+faststart",
+        str(output_path),
+    ])
+    completed = subprocess.run(command, stdout=output, stderr=output)
+    return completed.returncode
+
+
+def _media_duration_seconds(ffmpeg_path: str, path: Path) -> float | None:
+    completed = subprocess.run(
+        [ffmpeg_path, "-hide_banner", "-i", str(path)],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+    )
+    match = re.search(r"Duration: (?P<hours>\d+):(?P<minutes>\d+):(?P<seconds>\d+(?:\.\d+)?)", completed.stderr)
+    if not match:
+        return None
+    return (
+        int(match.group("hours")) * 3600
+        + int(match.group("minutes")) * 60
+        + float(match.group("seconds"))
+    )
+
+
+def _format_seconds(value: float) -> str:
+    return f"{value:.3f}"
+
+
+def _concat_path(path: Path) -> str:
+    return path.resolve().as_posix().replace("'", "'\\''")
+
+
+def _resolve_comskip(
+    comskip_path: str,
+    *,
+    require_comskip: bool,
+    auto_install: bool = False,
+    log: Callable[[str], None] | None = None,
+) -> str:
+    resolved = shutil.which(comskip_path)
+    if resolved:
+        return resolved
+    if comskip_path != "comskip":
+        return comskip_path
+    installed = _installed_comskip_path()
+    if installed.exists():
+        return str(installed)
+    if auto_install:
+        return str(install_comskip(log=log))
+    if require_comskip:
+        raise RuntimeError(
+            "Comskip was not found. On Windows, run with --comskip to auto-install it "
+            "inside the active Python environment."
+        )
+    return comskip_path
+
+
+def install_comskip(log: Callable[[str], None] | None = None) -> Path:
+    if platform.system() != "Windows":
+        raise RuntimeError("Automatic Comskip installation is currently supported on Windows only.")
+
+    target = _installed_comskip_path()
+    if target.exists():
+        return target
+
+    install_dir = target.parent
+    install_dir.mkdir(parents=True, exist_ok=True)
+    archive_path = install_dir / "comskip.zip"
+
+    _log(log, f"Downloading Comskip {COMSKIP_VERSION}...")
+    urllib.request.urlretrieve(COMSKIP_WINDOWS_URL, archive_path)
+    if COMSKIP_WINDOWS_SHA256:
+        _verify_sha256(archive_path, COMSKIP_WINDOWS_SHA256)
+    else:
+        _log(log, "Comskip checksum is not pinned; trusting the HTTPS download source.")
+
+    _log(log, f"Installing Comskip to {install_dir}")
+    with zipfile.ZipFile(archive_path) as archive:
+        _extract_zip_safely(archive, install_dir)
+
+    archive_path.unlink(missing_ok=True)
+    discovered = _find_comskip_exe(install_dir)
+    if not discovered:
+        raise RuntimeError(f"Comskip was downloaded, but comskip.exe was not found in {install_dir}.")
+    if discovered != target:
+        discovered.replace(target)
+    return target
+
+
+def _installed_comskip_path() -> Path:
+    return _comskip_install_dir() / "comskip.exe"
+
+
+def _comskip_install_dir() -> Path:
+    return Path(sys.prefix) / "share" / "tv-recorder" / "comskip" / COMSKIP_VERSION
+
+
+def _verify_sha256(path: Path, expected: str) -> None:
+    import hashlib
+
+    digest = hashlib.sha256(path.read_bytes()).hexdigest()
+    if digest.casefold() != expected.casefold():
+        path.unlink(missing_ok=True)
+        raise RuntimeError("Downloaded Comskip archive did not match the expected SHA256 checksum.")
+
+
+def _extract_zip_safely(archive: zipfile.ZipFile, target_dir: Path) -> None:
+    root = target_dir.resolve()
+    for member in archive.infolist():
+        target = (target_dir / member.filename).resolve()
+        if root != target and root not in target.parents:
+            raise RuntimeError(f"Unsafe path in Comskip archive: {member.filename}")
+    archive.extractall(target_dir)
+
+
+def _find_comskip_exe(root: Path) -> Path | None:
+    for path in root.rglob("*"):
+        if path.name.casefold() == "comskip.exe":
+            return path
+    return None
+
+
+def _log(log: Callable[[str], None] | None, message: str) -> None:
+    if log:
+        log(message)

{tv_recorder-0.0.0.dev2 → tv_recorder-0.0.0.dev3}/src/tv_recorder/config.py

@@ -20,6 +20,7 @@ class SourceConfig:
     stream_url_reject_patterns: tuple[str, ...] = ()
     output_extension: str = "mp4"
     recording: dict[str, Any] | None = None
+    comskip: dict[str, Any] | None = None
     steps: tuple[dict[str, Any], ...] = ()
     user_agent: str | None = None
 
@@ -54,6 +55,7 @@ def get_source(config: dict[str, Any], source_key: str) -> SourceConfig:
         stream_url_reject_patterns=tuple(raw.get("stream_url_reject_patterns") or ()),
         output_extension=raw.get("output_extension") or "mp4",
         recording=raw.get("recording"),
+        comskip=raw.get("comskip"),
         steps=tuple(raw.get("steps") or ()),
         user_agent=raw.get("user_agent"),
     )

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

@@ -21,6 +21,16 @@ sources:
         comment: "Français"
         reject_comments:
           - "audio_dv"
+    comskip:
+      min_segment_seconds: 15
+      min_break_seconds: 105
+      break_gap_tolerance_seconds: 2
+      ini:
+        min_commercial_size: 25
+        min_commercialbreak: 105
+        max_commercialbreak: 600
+        delete_show_before_first_commercial: 0
+        delete_show_after_last_commercial: 0
     steps: []
     user_agent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125 Safari/537.36"
   tvaplus.ca:
@@ -36,6 +46,16 @@ sources:
         direct_variant: false
       audio:
         language: "fre"
+    comskip:
+      min_segment_seconds: 15
+      min_break_seconds: 105
+      break_gap_tolerance_seconds: 2
+      ini:
+        min_commercial_size: 25
+        min_commercialbreak: 105
+        max_commercialbreak: 600
+        delete_show_before_first_commercial: 0
+        delete_show_after_last_commercial: 0
     steps:
       - action: wait_for_stream
     user_agent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125 Safari/537.36"

tv_recorder-0.0.0.dev3/tests/test_cli.py

@@ -0,0 +1,37 @@
+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"
+    )

tv_recorder-0.0.0.dev3/tests/test_comskip.py

@@ -0,0 +1,188 @@
+from pathlib import Path
+import shutil
+from uuid import uuid4
+from unittest.mock import patch
+
+import tv_recorder.comskip as comskip
+from tv_recorder.comskip import ComskipPlan, build_comskip_plan, cut_commercials, run_comskip
+
+
+def test_build_comskip_plan_uses_sidecar_paths() -> None:
+    recording = Path("recordings/show.ts")
+
+    plan = build_comskip_plan(
+        recording,
+        comskip_path="custom-comskip",
+        require_comskip=False,
+    )
+
+    assert plan.recording_path == recording
+    assert plan.edl_path == Path("recordings/show.edl")
+    assert plan.ini_path == Path("recordings/show.comskip.ini")
+    assert plan.commercial_free_path == Path("recordings/show.commercial-free.mp4")
+    assert plan.command == [
+        "custom-comskip",
+        f"--ini={Path('recordings/show.comskip.ini')}",
+        f"--output={Path('recordings')}",
+        str(Path("recordings/show.ts")),
+    ]
+
+
+def test_comskip_install_dir_lives_under_python_prefix(monkeypatch) -> None:
+    python_prefix = Path("C:/python-env")
+    monkeypatch.setattr(comskip.sys, "prefix", str(python_prefix))
+
+    assert comskip._comskip_install_dir() == (
+        python_prefix / "share" / "tv-recorder" / "comskip" / comskip.COMSKIP_VERSION
+    )
+
+
+def test_run_comskip_accepts_completed_processing_with_nonzero_exit() -> 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={
+                "min_segment_seconds": 15,
+                "min_break_seconds": 105,
+            },
+        )
+        plan.edl_path.write_text("1.0\t2.0\t0\n", encoding="utf-8")
+        recording.with_suffix(".txt").write_text(
+            "FILE PROCESSING COMPLETE  100 FRAMES AT  2997\n",
+            encoding="utf-8",
+        )
+
+        with patch("tv_recorder.comskip.subprocess.run") as run:
+            run.return_value.returncode = 1
+
+            assert run_comskip(plan) == 0
+    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)
+    try:
+        edl_path = work_dir / "show.edl"
+        edl_path.write_text("10.0\t20.5\t0\nbad line\n30\t40\t0\n", encoding="utf-8")
+
+        assert comskip._read_edl_cuts(edl_path) == [(10.0, 20.5), (30.0, 40.0)]
+    finally:
+        shutil.rmtree(work_dir, ignore_errors=True)
+
+
+def test_keep_intervals_are_complement_of_cuts() -> None:
+    assert comskip._keep_intervals([(10.0, 20.0), (30.0, 40.0)], 50.0) == [
+        (0.0, 10.0),
+        (20.0, 30.0),
+        (40.0, 50.0),
+    ]
+
+
+def test_cut_commercials_remuxes_when_edl_is_empty() -> None:
+    plan = ComskipPlan(
+        recording_path=Path("recordings/show.mp4"),
+        edl_path=Path("recordings/show.edl"),
+        ini_path=Path("recordings/show.comskip.ini"),
+        commercial_free_path=Path("recordings/show.commercial-free.mp4"),
+        command=["comskip", "recordings/show.mp4"],
+        options={},
+    )
+
+    with patch("tv_recorder.comskip.subprocess.run") as run:
+        run.return_value.returncode = 0
+
+        assert cut_commercials(plan, ffmpeg_path="ffmpeg") == 0
+
+    command = run.call_args.args[0]
+    assert command[-1] == str(plan.commercial_free_path)
+
+
+def test_cut_commercials_copies_single_remaining_interval() -> 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")
+        edl_path = work_dir / "show.edl"
+        edl_path.write_text("0.07\t234.11\t0\n", encoding="utf-8")
+        plan = ComskipPlan(
+            recording_path=recording,
+            edl_path=edl_path,
+            ini_path=work_dir / "show.comskip.ini",
+            commercial_free_path=work_dir / "show.commercial-free.mp4",
+            command=["comskip", str(recording)],
+            options={},
+        )
+
+        with (
+            patch("tv_recorder.comskip._media_duration_seconds", return_value=1500.05),
+            patch("tv_recorder.comskip.subprocess.run") as run,
+        ):
+            run.return_value.returncode = 0
+
+            assert cut_commercials(plan, ffmpeg_path="ffmpeg") == 0
+
+        command = run.call_args.args[0]
+        assert command[:8] == [
+            "ffmpeg",
+            "-y",
+            "-hide_banner",
+            "-loglevel",
+            "info",
+            "-ss",
+            "234.110",
+            "-i",
+        ]
+        assert "-f" not in command
+        assert command[-1] == str(plan.commercial_free_path)
+    finally:
+        shutil.rmtree(work_dir, ignore_errors=True)
+
+
+def test_build_ini_merges_channel_options() -> None:
+    ini = comskip._build_ini({
+        "ini": {
+            "min_commercialbreak": 105,
+            "max_commercialbreak": 600,
+        }
+    })
+
+    assert "output_edl=1\n" in ini
+    assert "min_commercialbreak=105\n" in ini
+    assert "max_commercialbreak=600\n" in ini
+
+
+def test_filter_cuts_rejects_short_false_positive() -> None:
+    cuts = [(598.73, 599.93)]
+    options = {
+        "min_segment_seconds": 15,
+        "min_break_seconds": 105,
+    }
+
+    assert comskip._filter_cuts(cuts, options) == []
+
+
+def test_filter_cuts_keeps_long_break() -> None:
+    cuts = [
+        (100.0, 130.0),
+        (130.5, 160.5),
+        (161.0, 191.0),
+        (191.5, 221.5),
+    ]
+    options = {
+        "min_segment_seconds": 15,
+        "min_break_seconds": 105,
+        "break_gap_tolerance_seconds": 2,
+    }
+
+    assert comskip._filter_cuts(cuts, options) == cuts

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

@@ -1,126 +0,0 @@
-from __future__ import annotations
-
-import argparse
-import shlex
-import sys
-import time
-from pathlib import Path
-
-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
-
-
-def build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(
-        prog="tv-recorder",
-        description="Find an HLS stream with Playwright and record it with ffmpeg.",
-    )
-    parser.add_argument("source", nargs="?", help="Source defined in YAML, ex: radio-canada.ca")
-    parser.add_argument("start", nargs="?", help="'now' or local ISO date, ex: 2026-05-24T20:00:00")
-    parser.add_argument("duration", nargs="?", help="Duration, ex: 30m, 2h, 90s, 01:30:00")
-    parser.add_argument("--config", type=Path, help="Path to a YAML source config file.")
-    parser.add_argument("--list", action="store_true", help="List available sources.")
-    parser.add_argument("--output-dir", type=Path, default=Path("recordings"), help="Output directory.")
-    parser.add_argument("--headful", action="store_true", help="Show Chromium while detecting the stream.")
-    parser.add_argument("--timeout-ms", type=int, default=45_000, help="Playwright timeout in milliseconds.")
-    parser.add_argument("--ffmpeg", default="ffmpeg", help="Override the bundled imageio-ffmpeg binary.")
-    parser.add_argument("--dry-run", action="store_true", help="Detect the stream and print the ffmpeg command.")
-    log_group = parser.add_mutually_exclusive_group()
-    log_group.add_argument("--info", dest="log_level", action="store_const", const="info", default="info", help="Show normal progress and selected HLS URLs.")
-    log_group.add_argument("--debug", dest="log_level", action="store_const", const="debug", help="Show discovery steps and ffmpeg output.")
-    return parser
-
-
-def main(argv: list[str] | None = None) -> int:
-    parser = build_parser()
-    args = parser.parse_args(argv)
-
-    try:
-        config = load_config(args.config)
-        if args.list:
-            list_sources(config)
-            return 0
-
-        missing = [name for name in ("source", "start", "duration") if getattr(args, name) is None]
-        if missing:
-            parser.error("source, start, and duration are required unless --list is used")
-
-        source = get_source(config, args.source)
-
-        start = parse_start(args.start)
-        duration_seconds = parse_duration(args.duration)
-        delay = seconds_until(start)
-
-        if delay > 0:
-            _info(args, f"Waiting until {start.isoformat()} ({int(delay)} s).")
-            time.sleep(delay)
-
-        _info(args, f"Detecting stream for {source.display_name}...")
-        stream = find_stream(
-            source,
-            headless=not args.headful,
-            timeout_ms=args.timeout_ms,
-            debug_log=lambda message: _debug(args, message),
-        )
-        output_path = build_output_path(args.output_dir, source, start)
-        plan = build_ffmpeg_plan(
-            stream,
-            output_path,
-            duration_seconds,
-            ffmpeg_path=args.ffmpeg,
-            require_ffmpeg=not args.dry_run,
-            recording=source.recording,
-        )
-        _print_stream_urls(args, stream)
-
-        if args.dry_run:
-            print("ffmpeg command:")
-            print(shlex.join(plan.command))
-            return 0
-
-        _info(args, f"Recording to {plan.output_path}")
-        exit_code = run_recording(plan, debug=args.log_level == "debug")
-        if exit_code != 0:
-            print(f"ffmpeg exited with code {exit_code}.", file=sys.stderr)
-        return exit_code
-    except Exception as exc:
-        print(f"Error: {exc}", file=sys.stderr)
-        return 1
-
-
-def list_sources(config: dict) -> None:
-    sources = config.get("sources") or {}
-    if not sources:
-        print("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
-        print(f"{key.ljust(width)}  {display_name}")
-
-
-def _info(args, message: str) -> None:
-    if args.log_level in {"info", "debug"}:
-        print(message, flush=True)
-
-
-def _debug(args, message: str) -> None:
-    if args.log_level == "debug":
-        print(f"DEBUG {message}", flush=True)
-
-
-def _print_stream_urls(args, stream) -> None:
-    discovered = stream.discovered_url or stream.url
-    _debug(args, f"Discovered HLS URL: {discovered}")
-    if stream.input_urls:
-        for index, input_url in enumerate(stream.input_urls, start=1):
-            _info(args, f"Recording HLS input {index}: {input_url}")
-        return
-    _info(args, f"Recording HLS URL: {stream.url}")
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())