ytstream/ytstream/strm.py

"""Materialising a video: write a `.strm`, an `.nfo` and a thumbnail.

This is what replaced youtube-automate's 330-line `download.py`. There is no
subprocess, no format selection, no progress parsing and no retry ladder, because
the whole job is writing a URL into a text file. Everything expensive was moved to
the moment somebody presses play, which is the point of the design.

Thumbnails come from `i.ytimg.com`, which needs no API key and no quota.
"""

from __future__ import annotations

import logging
import shutil
import sqlite3
import urllib.error
import urllib.request
from pathlib import Path

from . import config, naming, nfo, util, videos
from .settings import Settings

log = logging.getLogger(__name__)

THUMB_SUFFIX = "-thumb.jpg"

# maxres does not exist for every video; hq always does.
_THUMB_URLS = (
    "https://i.ytimg.com/vi/{vid}/maxresdefault.jpg",
    "https://i.ytimg.com/vi/{vid}/hqdefault.jpg",
)


def watch_url(settings: Settings, video_id: str) -> str:
    base = settings.get_str("proxy_base_url").rstrip("/")
    return f"{base}/watch/{video_id}"


def channel_dir(channel: sqlite3.Row) -> Path:
    return config.MEDIA_ROOT / channel["dir_name"]


def episode_paths(channel: sqlite3.Row, season: int, episode: int,
                  title: str, video_id: str) -> tuple[Path, str]:
    """(.strm path, path relative to the media root)."""
    stem = naming.basename(channel["dir_name"], season, episode, title, video_id)
    relative = Path(channel["dir_name"]) / naming.season_dir_name(season) / (stem + ".strm")
    return config.MEDIA_ROOT / relative, str(relative)


def write_show(channel: sqlite3.Row) -> None:
    """tvshow.nfo for a channel.

    Takes the row's show fields explicitly rather than trusting a joined row: the
    channel/video join has `title` on both sides, and reading the wrong one
    renamed every series after whichever episode happened to be first. That
    shipped once already.
    """
    directory = channel_dir(channel)
    directory.mkdir(parents=True, exist_ok=True)
    nfo.write(
        directory / "tvshow.nfo",
        nfo.tvshow_nfo(
            title=channel["title"],
            plot=channel["description"],
            channel_id=channel["channel_id"],
        ),
    )


def fetch_thumbnail(video_id: str, destination: Path, *, timeout: float = 20.0) -> bool:
    """Best effort. A missing thumbnail is cosmetic, never a failure."""
    if destination.exists():
        return True
    for template in _THUMB_URLS:
        url = template.format(vid=video_id)
        request = urllib.request.Request(url, headers={"User-Agent": config.USER_AGENT})
        try:
            with urllib.request.urlopen(request, timeout=timeout) as response:
                if response.status != 200:
                    continue
                payload = response.read()
        except (urllib.error.HTTPError, urllib.error.URLError, OSError):
            continue
        if len(payload) < 1024:
            # YouTube serves a 120-byte grey placeholder rather than a 404.
            continue
        destination.parent.mkdir(parents=True, exist_ok=True)
        temporary = destination.with_name(destination.name + ".tmp")
        temporary.write_bytes(payload)
        temporary.replace(destination)
        return True
    log.debug("no thumbnail available for %s", video_id)
    return False


def materialise(
    conn: sqlite3.Connection,
    settings: Settings,
    channel: sqlite3.Row,
    video: sqlite3.Row,
) -> dict:
    """Write one episode's `.strm`, `.nfo` and thumbnail, and record it.

    Idempotent: re-running over an already-materialised video rewrites the same
    bytes to the same paths.
    """
    upload_date = naming.parse_upload_date(video["upload_date"])
    season, episode = videos.next_episode(
        conn, channel["id"], upload_date, video["video_id"]
    )
    # `title` is for the filename; `stored_title` is what goes back to the
    # database. They differ when we have no title yet: writing the video id back
    # would make the row look titled, permanently disabling the repair path in
    # discovery._record that fills titles in from a later feed poll. That bug
    # shipped once and renamed five of twenty episodes after their video ids.
    stored_title = video["title"] or ""
    title = stored_title or video["video_id"]
    strm_path, relative = episode_paths(
        channel, season, episode, title, video["video_id"]
    )

    strm_path.parent.mkdir(parents=True, exist_ok=True)
    # No trailing newline: some Jellyfin versions have historically been fussy
    # about trailing whitespace in .strm files, and there is nothing to gain.
    temporary = strm_path.with_name(strm_path.name + ".tmp")
    temporary.write_text(watch_url(settings, video["video_id"]), encoding="utf-8")
    temporary.replace(strm_path)

    nfo.write(
        strm_path.with_suffix(".nfo"),
        nfo.episode_nfo(
            title=title,
            show_title=channel["title"],
            season=season,
            episode=episode,
            plot=None,
            aired=upload_date.isoformat(),
            duration_seconds=video["duration"],
            video_id=video["video_id"],
        ),
    )

    stem = strm_path.name[: -len(".strm")]
    fetch_thumbnail(video["video_id"], strm_path.with_name(stem + THUMB_SUFFIX))

    videos.mark_materialised(
        conn,
        video["video_id"],
        rel_path=relative,
        season=season,
        episode=episode,
        upload_date=upload_date.isoformat(),
        duration=video["duration"],
        title=stored_title,
    )
    return {"video_id": video["video_id"], "rel_path": relative,
            "season": season, "episode": episode}


def remove(video: sqlite3.Row) -> int:
    """Delete an episode's files. Returns how many were removed.

    Only touches suffixes we know we wrote. A stray file someone else put in the
    season directory is not ours to delete.
    """
    if not video["rel_path"]:
        return 0
    strm_path = config.MEDIA_ROOT / video["rel_path"]
    stem = strm_path.name[: -len(".strm")]
    removed = 0
    for path in [strm_path] + [
        strm_path.with_name(stem + suffix) for suffix in config.SIDECAR_SUFFIXES
    ]:
        try:
            path.unlink()
            removed += 1
        except FileNotFoundError:
            continue
        except OSError as exc:
            log.warning("could not remove %s: %s", path, exc)

    # Prune empty season directories, but stop at the channel directory — it
    # holds tvshow.nfo and the artwork, and an active subscription must not
    # vanish from Jellyfin just because it published nothing this year. Passing
    # MEDIA_ROOT as the boundary instead would delete the channel directory on
    # any channel whose tvshow.nfo happened to be missing.
    channel_dir = config.MEDIA_ROOT / Path(video["rel_path"]).parts[0]
    util.prune_empty_dirs(strm_path.parent, channel_dir)
    return removed


def remove_channel_tree(channel: sqlite3.Row) -> bool:
    """Delete a whole channel directory, on unsubscribe.

    Guarded against deleting the media root itself, which a channel whose
    dir_name somehow ended up empty would otherwise do.
    """
    directory = channel_dir(channel)
    if directory == config.MEDIA_ROOT or not str(channel["dir_name"]).strip():
        log.error("refusing to remove %s: unsafe channel directory", directory)
        return False
    if not directory.exists():
        return False
    shutil.rmtree(directory)
    log.info("removed %s", directory)
    return True