tinyjukebox 0.47.0__py3-none-any.whl

tinyjukebox/tools/backup.py

@@ -0,0 +1,173 @@
+"""Fetch a backup of a box or of the library to this computer::
+
+    tinyjukebox-backup https://nas:8866 --user admin                         # into the current folder
+    tinyjukebox-backup https://tinyjukebox.local --user admin --albums ~/backups
+
+or set the folders in which the library - or a box without a library - keeps the backups that it makes by itself,
+the one for the backups without the albums and the one for those with them::
+
+    tinyjukebox-backup https://nas:8866 --user admin --library-folder /volume1/tinyjukebox/backups
+    tinyjukebox-backup https://nas:8866 --user admin --library-folder-albums /volume2/backups-with-mp3s
+
+or put a backup back - it replaces all data of the box or of the library::
+
+    tinyjukebox-backup https://nas:8866 --user admin --restore tinyjukebox-library-20261010-030000.tar.gz
+
+Without ``--albums`` the backup holds everything but the audio files of the albums and is small; with it, it holds
+them as well and is as large as all albums together. Nothing secret is part of a backup. The file is read to its end
+before it gets its name: a backup that was cut off on the way is not kept. What a backup contains and how it is put
+back: docs/developer/operations.md, section 10.
+"""
+
+import argparse
+import contextlib
+import getpass
+import os
+import sys
+from collections.abc import Callable, Sequence
+from typing import Any
+
+from tinyjukebox.backup import NAME, PART, Incomplete, verify
+from tinyjukebox.sync.client import Client, HttpError, Unreachable, WrongCertificate
+from tinyjukebox.tools.fill_library import _client
+
+__all__ = ["fetch", "main", "restore", "set_library_folder"]
+
+KEPT = ("/api/library/backups", "/api/backups")  # the schedules of the library, and of a box without a library
+
+
+def fetch(client: Client, folder: str, albums: bool) -> tuple[str, dict[str, Any]]:
+    """Fetch a backup into ``folder``; returns its file and what it says about itself
+    (:func:`tinyjukebox.backup.verify`). ``client`` is logged in as an admin.
+
+    :raises Incomplete: if what arrived is no complete backup - nothing is kept then.
+    """
+    part = os.path.join(folder, f".tinyjukebox-backup{PART}")
+    with contextlib.suppress(FileNotFoundError):
+        os.remove(part)  # the client would continue a file that is there
+    try:
+        answer = client.request("GET", "/api/backup" + ("?albums=1" if albums else ""), sink=part)
+        name = (answer.headers.get_filename() or "").strip()
+        if NAME.fullmatch(name) is None:
+            raise Incomplete(f"the answer names no backup: {name!r}")
+        about = verify(part)
+        target = os.path.join(folder, name)
+        os.replace(part, target)
+    finally:
+        with contextlib.suppress(FileNotFoundError):
+            os.remove(part)
+    return target, about
+
+
+def restore(client: Client, filename: str, confirm: Callable[[dict[str, Any]], bool] | None = None) -> dict[str, Any]:
+    """Put the backup in ``filename`` back on a box or on the library: it is sent and unpacked there beside the data,
+    read to its end. ``confirm(status)`` decides then (None: yes); a backup that is not confirmed is discarded there.
+    Returns the status of the restore: ``confirmed`` - the other side starts again with the data of the backup.
+
+    :raises HttpError: if the other side refuses the backup, e.g. one of the other kind or one that was cut off.
+    """
+    status: dict[str, Any] = client.request("PUT", "/api/restore", upload=filename).json()
+    if confirm is not None and not confirm(status):
+        return dict(client.delete("/api/restore"))
+    return dict(client.post("/api/restore/confirm"))
+
+
+def _ask(status: dict[str, Any]) -> bool:
+    about = status["about"]
+    _say(f"This replaces all data of the {status['kind']} by those of the backup of {about['created']}.")
+    if about.get("albums"):
+        _say("With MP3s: all albums are deleted and replaced.")
+    if status.get("library"):
+        _say("This box works with a library: at its next synchronization the box gets the state of the library again.")
+    _say("No backup is made before. Make one first if the data of now may be needed again.")
+    return input("Put it back? [y/N] ").strip().lower() == "y"
+
+
+def _say(text: str) -> None:
+    print(text, flush=True)
+
+
+def set_library_folder(client: Client, folder: str, albums: bool = False) -> str:
+    """Set the folder in which the library keeps the backups that it makes by itself - those without the albums or,
+    with ``albums``, those with them; returns the folder that counts now. ``client`` is logged in as an admin of the
+    library, or of a box that keeps backups.
+
+    :raises HttpError: if the folder cannot be written to, or if nothing keeps backups there.
+    """
+    kind = "albums" if albums else "plain"
+    for path in KEPT:
+        try:
+            return str(client.put(path, {kind: {"folder": folder}})[kind]["folder"])
+        except HttpError as error:
+            if error.status != 404:
+                raise
+    raise HttpError(404, "no backups are kept there: it is neither a library nor a box of this version")
+
+
+def main(argv: Sequence[str] | None = None) -> None:
+    """Console script ``tinyjukebox-backup``."""
+    parser = argparse.ArgumentParser(description="Fetch a backup of a box or of the library to this computer.")
+    parser.add_argument("address", help="address of the box or of the library, e.g. https://nas:8866")
+    parser.add_argument("folder", nargs="?", default=".", help="where the backup is put (default: the current folder)")
+    parser.add_argument("--albums", action="store_true", help="with the audio files of the albums")
+    parser.add_argument(
+        "--library-folder",
+        metavar="FOLDER",
+        help="fetch nothing: set the folder on the computer of the library in which it keeps the backups without "
+        "the albums that it makes by itself ('' for the one of its config)",
+    )
+    parser.add_argument(
+        "--library-folder-albums",
+        metavar="FOLDER",
+        help="fetch nothing: the same for the backups with the albums",
+    )
+    parser.add_argument(
+        "--restore",
+        metavar="FILE",
+        help="fetch nothing: put this backup back - it replaces all data of the box or of the library, which starts "
+        "again",
+    )
+    parser.add_argument("--yes", action="store_true", help="with --restore: do not ask before the data is replaced")
+    parser.add_argument("--user", required=True, help="an admin of the web page")
+    parser.add_argument("--password-file", help="file with the password (default: asked for)")
+    parser.add_argument("--fingerprint", help="sha256 fingerprint of the certificate (else: shown and asked)")
+    arguments = parser.parse_args(argv)
+    folder = os.path.expanduser(arguments.folder)
+    folders = [(arguments.library_folder, False), (arguments.library_folder_albums, True)]
+    folders = [(kept, albums) for kept, albums in folders if kept is not None]
+    if arguments.restore is not None and not os.path.isfile(os.path.expanduser(arguments.restore)):
+        sys.exit(f"'{arguments.restore}' is no file")
+    if not folders and arguments.restore is None and not os.path.isdir(folder):
+        sys.exit(f"'{folder}' is no folder")
+    if arguments.password_file:
+        with open(arguments.password_file, encoding="utf-8") as infile:
+            password = infile.read().strip()
+    else:
+        password = getpass.getpass(f"Password of {arguments.user}: ")
+    try:
+        client = _client(arguments.address.rstrip("/"), arguments.fingerprint, True, "the box or library")
+        token = client.post("/api/login", {"username": arguments.user, "password": password})["token"]
+        client.headers["Authorization"] = f"Bearer {token}"
+        if arguments.restore is not None:
+            _say("sending the backup - it is read to its end there and unpacked beside the data")
+            status = restore(client, os.path.expanduser(arguments.restore), None if arguments.yes else _ask)
+            _say(
+                "put back: it starts again with the data of the backup"
+                if status["state"] == "confirmed"
+                else "not put back"
+            )
+            return
+        for kept, albums in folders:
+            what = "its backups with the albums" if albums else "its backups"
+            print(f"the library keeps {what} in {set_library_folder(client, kept, albums)}")
+        if folders:
+            return
+        target, about = fetch(client, folder, arguments.albums)
+    except (Unreachable, WrongCertificate, HttpError, Incomplete, OSError) as error:
+        sys.exit(f"no backup: {error}")
+    print(
+        f"{target}: backup of a {about['kind']} (version {about['version']}), {about['files']} files, "
+        f"{about['bytes']} bytes"
+    )
+    for name in about["skipped"]:
+        print(f"  left out, it disappeared while it was read: {name}")

tinyjukebox/tools/fill_library.py

@@ -0,0 +1,120 @@
+"""Fill the library from what is at hand on this computer (docs/developer/library.md, section 3.5)::
+
+    tinyjukebox-fill-library https://nas:8866 --user admin --json ~/tinyjukebox/json --albums ~/tinyjukebox/albums \\
+        --images ~/tinyjukebox/json/images
+
+Tags, albums with their files, stations and their covers are taken over under their ids, so that a box that has the
+same data and the library agree from the start. The command can be repeated: what is there already is skipped. The
+positions come from the boxes themselves.
+"""
+
+import argparse
+import getpass
+import os
+import sys
+from collections.abc import Sequence
+from typing import Any
+
+from tinyjukebox.images import is_cover
+from tinyjukebox.sync import handshake
+from tinyjukebox.sync import manifest as manifests
+from tinyjukebox.sync.client import Client, HttpError, Unreachable, WrongCertificate
+from tinyjukebox.sync.files import _quoted
+from tinyjukebox.sync.util import read_json
+
+__all__ = ["fill", "main"]
+
+
+def _say(text: str) -> None:
+    print(text)
+
+
+def _client(url: str, fingerprint: str | None, confirm: bool, server: str = "the library") -> Client:
+    """A client that accepts the certificate of the library only. The library has a self-signed certificate, so
+    its fingerprint is compared with the one that is expected - or, like ssh, shown and asked for. ``server`` names
+    the other side in the texts, for a command that also talks to a box."""
+    probe = Client(url)
+    probe.request("GET", "/favicon.svg")
+    certificate = probe.peer_certificate or ""
+    found = handshake.fingerprint(certificate)
+    if fingerprint is not None:
+        if found.lower() != fingerprint.replace(":", "").lower():
+            raise WrongCertificate(f"{server} presents a certificate with the fingerprint {found}")
+    elif confirm:
+        _say(f"{server[:1].upper()}{server[1:]} presents a certificate with the sha256 fingerprint\n  {found}")
+        hint = " (its log shows the fingerprint at the start)" if server == "the library" else ""
+        if input(f"Is this {server}{hint}? [y/N] ").strip().lower() != "y":
+            raise WrongCertificate("not confirmed")
+    return Client(url, certificate=certificate, timeout=60.0)
+
+
+def fill(
+    client: Client, json_folder: str, albums_folder: str | None, images_folder: str | None, say: Any = _say
+) -> dict[str, int]:
+    """Send the catalog in ``json_folder``, the albums and the covers of the stations. ``client`` is logged in as an
+    admin."""
+    targets = read_json(os.path.join(json_folder, "targets.json"), {})
+    tags = read_json(os.path.join(json_folder, "tags.json"), {})
+    # a tag that is linked to nothing that exists is not linked
+    for tag in tags.values():
+        if str(tag.get("target", {}).get("id")) not in targets:
+            tag["target"] = {"type": tag.get("target", {}).get("type") or "album", "id": -1}
+    taken = client.post("/api/library/fill", {"targets": targets, "tags": tags})
+    counts = {name: len(keys) for name, keys in taken.items()}
+    say(f"taken over: {counts['targets']} targets, {counts['tags']} tags")
+    counts["files"] = counts["images"] = 0
+    for key, target in targets.items() if albums_folder else []:
+        if target.get("target-type") != "album":
+            continue
+        folder = os.path.join(albums_folder or "", target["album-folder"])
+        try:
+            manifest = manifests.create(folder, target["playlist"])
+        except OSError as error:
+            say(f"album {key} ({target['album-folder']}): cannot be read here, skipped ({error})")
+            continue
+        try:
+            lacks = client.post(f"/api/library/fill/albums/{key}", {"manifest": manifest})["lacks"]
+        except HttpError as error:
+            say(f"album {key} ({target['album-folder']}): {error}")
+            continue
+        for name in lacks:
+            client.request(
+                "PUT", f"/api/library/fill/albums/{key}/files/{_quoted(name)}", upload=manifests.path(folder, name)
+            )
+            counts["files"] += 1
+        say(f"album {key} ({target['album-folder']}): {len(lacks)} of {len(manifest['files'])} files sent")
+    if images_folder:
+        for name in sorted(os.listdir(images_folder)):
+            if is_cover(name):
+                filename = os.path.join(images_folder, name)
+                client.request("PUT", f"/api/library/fill/images/{_quoted(name)}", upload=filename)
+                counts["images"] += 1
+        say(f"{counts['images']} covers of stations sent; the library keeps the ones it lacked")
+    return counts
+
+
+def main(argv: Sequence[str] | None = None) -> None:
+    """Console script ``tinyjukebox-fill-library``."""
+    parser = argparse.ArgumentParser(
+        description="Fill the library from the json files, albums and station covers here."
+    )
+    parser.add_argument("library", help="address of the library, e.g. https://nas:8866")
+    parser.add_argument("--user", required=True, help="an admin of the page of the library")
+    parser.add_argument("--password-file", help="file with the password (default: asked for)")
+    parser.add_argument("--json", required=True, help="folder with tags.json and targets.json")
+    parser.add_argument("--albums", help="albums folder - album-folder entries of targets.json are relative to it")
+    parser.add_argument("--images", help="folder with the covers of the radio stations")
+    parser.add_argument("--fingerprint", help="sha256 fingerprint of the certificate of the library (else: asked)")
+    arguments = parser.parse_args(argv)
+    if arguments.password_file:
+        with open(arguments.password_file, encoding="utf-8") as infile:
+            password = infile.read().strip()
+    else:
+        password = getpass.getpass(f"Password of {arguments.user}: ")
+    try:
+        client = _client(arguments.library.rstrip("/"), arguments.fingerprint, confirm=True)
+        token = client.post("/api/login", {"username": arguments.user, "password": password})["token"]
+        client.headers["Authorization"] = f"Bearer {token}"
+        fill(client, arguments.json, arguments.albums, arguments.images)
+    except (Unreachable, WrongCertificate, HttpError) as error:
+        sys.exit(f"the library was not filled: {error}")

tinyjukebox/tools/import_cards.py

@@ -0,0 +1,274 @@
+"""tinyjukebox-import-cards - cut the pictures of cards out of a PowerPoint file (several cards per slide) into a
+folder.
+
+    tinyjukebox-import-cards cards.pptx OUTPUT-FOLDER --grid 2x2 --slides 1,3,5
+
+Needs LibreOffice (pptx -> pdf) and pdftoppm (poppler-utils). Every grid cell that contains at least one picture
+becomes a card image '<prefix><slide>-<cell>-<title>.jpg'; the texts on the card are stored as caption in
+captions.json. Use --prefix to keep the cards of several files apart in one folder.
+To make the images covers of albums, name them ``album-<id>.jpg`` and list them in captions.json
+(``tinyjukebox-import-covers``).
+"""
+
+import argparse
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import zipfile
+from collections.abc import Callable, Sequence
+from typing import Any
+from xml.etree import ElementTree
+
+__all__ = ["cards_of_slide", "main", "read_presentation", "slug"]
+
+NS = {
+    "p": "http://schemas.openxmlformats.org/presentationml/2006/main",
+    "a": "http://schemas.openxmlformats.org/drawingml/2006/main",
+}
+CAPTIONS_FILE = "captions.json"
+
+
+def _slide_names(archive: zipfile.ZipFile) -> list[str]:
+    """Slide xml files in presentation order."""
+    names = [n for n in archive.namelist() if re.match(r"ppt/slides/slide\d+\.xml$", n)]
+    return sorted(names, key=lambda n: int(re.sub(r"\D", "", n.rsplit("/", 1)[1])))
+
+
+def _xfrm(element: ElementTree.Element, properties: str) -> tuple[int, int, int, int, ElementTree.Element] | None:
+    """(x, y, cx, cy, xfrm element) of a shape or None."""
+    xfrm = element.find(f"p:{properties}/a:xfrm", NS)
+    if xfrm is None:
+        return None
+    off, ext = xfrm.find("a:off", NS), xfrm.find("a:ext", NS)
+    if off is None or ext is None:
+        return None
+    return int(off.get("x", 0)), int(off.get("y", 0)), int(ext.get("cx", 0)), int(ext.get("cy", 0)), xfrm
+
+
+Transform = Callable[[int, int, int, int], tuple[int, int, int, int]]
+Shape = tuple[str, int, int, int, int, str]
+
+
+def _identity(x: int, y: int, cx: int, cy: int) -> tuple[int, int, int, int]:
+    return x, y, cx, cy
+
+
+def _shapes(element: ElementTree.Element, transform: Transform = _identity) -> list[Shape]:
+    """(kind, x, y, cx, cy, text) of all pictures and text shapes in slide coordinates - groups are resolved."""
+    result: list[Shape] = []
+    for child in element:
+        tag = child.tag.split("}")[1]
+        if tag == "grpSp":
+            position = _xfrm(child, "grpSpPr")
+            if position is None:
+                continue
+            x, y, cx, cy, xfrm = position
+            ch_off, ch_ext = xfrm.find("a:chOff", NS), xfrm.find("a:chExt", NS)
+            if ch_off is None or ch_ext is None:
+                continue
+            cox, coy = int(ch_off.get("x", 0)), int(ch_off.get("y", 0))
+            ccx, ccy = max(1, int(ch_ext.get("cx", 1))), max(1, int(ch_ext.get("cy", 1)))
+
+            def child_transform(
+                x2: int,
+                y2: int,
+                cx2: int,
+                cy2: int,
+                x: int = x,
+                y: int = y,
+                cx: int = cx,
+                cy: int = cy,
+                cox: int = cox,
+                coy: int = coy,
+                ccx: int = ccx,
+                ccy: int = ccy,
+                outer: Transform = transform,
+            ) -> tuple[int, int, int, int]:
+                return outer(x + (x2 - cox) * cx // ccx, y + (y2 - coy) * cy // ccy, cx2 * cx // ccx, cy2 * cy // ccy)
+
+            result += _shapes(child, child_transform)
+            continue
+        if tag not in ("pic", "sp"):
+            continue
+        position = _xfrm(child, "spPr")
+        if position is None:
+            continue
+        x, y, cx, cy = transform(*position[:4])
+        if tag == "pic":
+            result.append(("pic", x, y, cx, cy, ""))
+        else:
+            paragraphs = ["".join(t.text or "" for t in p.findall(".//a:t", NS)) for p in child.findall(".//a:p", NS)]
+            text = " ".join(p.strip() for p in paragraphs if p.strip())
+            if text:
+                result.append(("text", x, y, cx, cy, text))
+    return result
+
+
+def read_presentation(filename: str) -> tuple[int, int, list[list[Shape]]]:
+    """Returns (slide width, slide height, [shapes of slide 1, shapes of slide 2, ...]) in EMU."""
+    with zipfile.ZipFile(filename) as archive:
+        presentation = ElementTree.fromstring(archive.read("ppt/presentation.xml"))  # noqa: S314
+        size = presentation.find("p:sldSz", NS)
+        slides = []
+        for name in _slide_names(archive):
+            tree = ElementTree.fromstring(archive.read(name))  # noqa: S314
+            tree_root = tree.find(".//p:spTree", NS)
+            slides.append(_shapes(tree_root) if tree_root is not None else [])
+    if size is None:
+        raise SystemExit(f"'{filename}' has no slide size.")
+    return int(size.get("cx", 0)), int(size.get("cy", 0)), slides
+
+
+def cards_of_slide(
+    shapes: list[Shape], width: int, height: int, columns: int, rows: int
+) -> list[tuple[int, int, list[str]]]:
+    """Grid cells with at least one picture: [(column, row, caption texts)] - a shape belongs to the cell of its
+    center. Texts of a single character (the cell letters of the template) are no captions."""
+    cells: dict[tuple[int, int], dict[str, Any]] = {}
+    for kind, x, y, cx, cy, text in shapes:
+        column = min(columns - 1, max(0, (x + cx // 2) * columns // width))
+        row = min(rows - 1, max(0, (y + cy // 2) * rows // height))
+        cell = cells.setdefault((column, row), {"pictures": 0, "texts": []})
+        if kind == "pic":
+            cell["pictures"] += 1
+        elif len(text) > 1:
+            cell["texts"].append(text)
+    return [
+        (c, r, cells[(c, r)]["texts"])
+        for r in range(rows)
+        for c in range(columns)
+        if (c, r) in cells and cells[(c, r)]["pictures"] > 0
+    ]
+
+
+def slug(text: str, length: int = 40) -> str:
+    text = re.sub(r"[^\w]+", "-", text, flags=re.UNICODE).strip("-").lower()
+    return text[:length].strip("-") or "karte"
+
+
+def convert_to_pdf(pptx: str, folder: str) -> str:
+    office = shutil.which("soffice") or shutil.which("libreoffice")
+    if office is None:
+        raise SystemExit("LibreOffice (soffice) not found.")
+    # snap packages cannot read hidden folders or /tmp - work on a copy in the output folder
+    copy = os.path.join(folder, "cards.pptx")
+    shutil.copy(pptx, copy)
+    subprocess.run(
+        [office, "--headless", "--convert-to", "pdf", "--outdir", folder, copy],
+        check=True,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+    os.remove(copy)
+    pdf = os.path.join(folder, "cards.pdf")
+    if not os.path.exists(pdf):
+        raise SystemExit(f"converting '{pptx}' to pdf failed.")
+    return pdf
+
+
+def render_cell(
+    pdf: str,
+    slide: int,
+    column: int,
+    row: int,
+    columns: int,
+    rows: int,
+    width_px: int,
+    height_px: int,
+    dpi: int,
+    target: str,
+) -> None:
+    cell_w, cell_h = width_px // columns, height_px // rows
+    base = target[:-4]
+    subprocess.run(
+        [
+            "pdftoppm",
+            "-jpeg",
+            "-jpegopt",
+            "quality=85",
+            "-r",
+            str(dpi),
+            "-f",
+            str(slide),
+            "-l",
+            str(slide),
+            "-x",
+            str(column * cell_w),
+            "-y",
+            str(row * cell_h),
+            "-W",
+            str(cell_w),
+            "-H",
+            str(cell_h),
+            "-singlefile",
+            pdf,
+            base,
+        ],
+        check=True,
+    )
+
+
+def main(argv: Sequence[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(prog="tinyjukebox-import-cards", description=(__doc__ or "").split("\n\n")[0])
+    parser.add_argument("pptx", help="PowerPoint file with the card fronts")
+    parser.add_argument("folder", help="folder for the images")
+    parser.add_argument("--grid", default="2x2", help="cards per slide as COLUMNSxROWS (default: 2x2)")
+    parser.add_argument("--slides", help="comma separated slide numbers (default: every slide with pictures)")
+    parser.add_argument("--dpi", type=int, default=150, help="resolution of the card images (default: 150)")
+    parser.add_argument("--prefix", default="", help="start of the image names, e.g. 'b' for a second file")
+    args = parser.parse_args(argv)
+
+    if shutil.which("pdftoppm") is None:
+        raise SystemExit("pdftoppm not found - install poppler-utils.")
+    columns, rows = (int(v) for v in args.grid.lower().split("x"))
+    width, height, slides = read_presentation(args.pptx)
+    selected = [int(s) for s in args.slides.split(",")] if args.slides else list(range(1, len(slides) + 1))
+    if any(not 1 <= number <= len(slides) for number in selected):
+        raise SystemExit(f"slide numbers must be between 1 and {len(slides)}.")
+    if columns * rows > 26 or min(columns, rows) < 1:
+        raise SystemExit("the grid must have 1 to 26 cells.")
+    if not re.fullmatch(r"[\w-]*", args.prefix):
+        raise SystemExit("the prefix may only contain letters, digits, '-' and '_'.")
+    os.makedirs(args.folder, exist_ok=True)
+    captions_file = os.path.join(args.folder, CAPTIONS_FILE)
+    try:
+        with open(captions_file, encoding="UTF-8") as f:
+            captions = json.load(f)
+    except (FileNotFoundError, ValueError):
+        captions = {}
+
+    width_px = round(width / 914400 * args.dpi)
+    height_px = round(height / 914400 * args.dpi)
+    with tempfile.TemporaryDirectory(dir=args.folder) as work:
+        pdf = convert_to_pdf(args.pptx, work)
+        count = 0
+        for number in selected:
+            for column, row, texts in cards_of_slide(slides[number - 1], width, height, columns, rows):
+                cell = "abcdefghijklmnopqrstuvwxyz"[row * columns + column]
+                name = f"{args.prefix}{number:02d}-{cell}-{slug(texts[0] if texts else 'karte')}.jpg"
+                render_cell(
+                    pdf,
+                    number,
+                    column,
+                    row,
+                    columns,
+                    rows,
+                    width_px,
+                    height_px,
+                    args.dpi,
+                    os.path.join(args.folder, name),
+                )
+                captions[name] = " · ".join(texts)
+                count += 1
+                print(f"{name}  {captions[name]}")
+    with open(captions_file, "w", encoding="UTF-8") as f:
+        json.dump(captions, f, indent=2, sort_keys=True, ensure_ascii=False)
+    print(f"{count} card images in '{args.folder}'.", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()