Dymas/dilydl
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Dymas
2026-07-13 20:04:57 +02:00
commit 13f3be5ed0
3 changed files with 898 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.gitignore
+14
View File
@@ -0,0 +1,14 @@
.gitrepo/
cookie*.txt
auth*.txt
headers*.txt
token*.txt
*.pdf
downloaded_pages/
pages/
test_pages/
cookie_test_pages/
mzk_cookie_20_pages/
generalized_test_pages/
kniha/
__pycache__/
README.md
+139
View File
@@ -0,0 +1,139 @@
# Kramerius PDF Downloader
Download page images from Digitalniknihovna / Kramerius and assemble them into a PDF.
The script:
- discovers all page UUIDs for a document
- downloads each page image
- embeds the downloaded JPEGs into a PDF
- can resume interrupted downloads by skipping existing images
- supports authenticated downloads with a Kramerius bearer token
- can resolve other `digitalniknihovna.cz/<library>/...` links automatically
## Requirements
Python 3.10 or newer is recommended. The script uses only the Python standard library, so no `pip install` step is needed.
## Basic Usage
```bash
python3 download_kramerius_pdf.py "https://www.digitalniknihovna.cz/mzk/view/uuid:0abf59c0-794e-11e4-8ce5-005056827e52?page=uuid:e57e2820-8547-11e4-a321-5ef3fc9bb22f" \
--output-dir pages \
--pdf book.pdf
```
To test only the first few pages:
```bash
python3 download_kramerius_pdf.py "URL_HERE" \
--limit 20 \
--output-dir test_pages \
--pdf test.pdf
```
If a run is interrupted, run the same command again. Existing images are skipped unless you pass `--overwrite`.
## Authenticated Downloads
Some pages require a logged-in account. The Digitalniknihovna web app sends protected image requests with:
```text
Authorization: Bearer <token>
Client: www.digitalniknihovna.cz
```
Use either `--auth-token`:
```bash
python3 download_kramerius_pdf.py "URL_HERE" \
--auth-token "PASTE_TOKEN_HERE" \
--output-dir pages \
--pdf book.pdf
```
Or put the token in `auth-token.txt` and use `--auth-file`:
```bash
python3 download_kramerius_pdf.py "URL_HERE" \
--auth-file auth-token.txt \
--output-dir pages \
--pdf book.pdf
```
`auth-token.txt` may contain either the raw token or a copied header like:
```text
Authorization: Bearer eyJ...
```
## How To Get The Auth Token
1. Log in on `https://www.digitalniknihovna.cz`.
2. Open the protected book page in the browser.
3. Open browser developer tools:
- Chrome / Edge: `F12` or `Ctrl+Shift+I`
- Firefox: `F12`
4. Go to the **Application** tab.
5. Open **Local storage** in the left sidebar.
6. Select:
```text
https://www.digitalniknihovna.cz
```
7. Find the key for your library. For MZK it is:
```text
auth.token.mzk
```
8. Copy the value and save it in `auth-token.txt`, or pass it directly with `--auth-token`.
For another library, the key usually follows the same pattern:
```text
auth.token.<library-code>
```
For example, a URL containing `/mzk/view/...` uses `auth.token.mzk`.
## Using Other Digitalniknihovna URLs
Paste the document URL directly:
```bash
python3 download_kramerius_pdf.py "https://www.digitalniknihovna.cz/LIBRARY_CODE/view/uuid:..." \
--auth-file auth-token.txt \
--output-dir pages \
--pdf book.pdf
```
The script reads the library code from the URL and tries to resolve the correct Kramerius API backend automatically. If that fails, pass the API backend manually:
```bash
python3 download_kramerius_pdf.py "URL_HERE" \
--library mzk \
--base-url "https://api.kramerius.mzk.cz" \
--auth-file auth-token.txt \
--output-dir pages \
--pdf book.pdf
```
## Useful Options
```text
--limit N Download only the first N pages
--overwrite Redownload images that already exist
--delay SECONDS Wait between image downloads
--cookies FILE Send cookies from a cookies.txt export
--auth-token TOKEN Send Authorization: Bearer TOKEN
--auth-file FILE Read token or headers from a file
--client VALUE Override the Client header
```
## Security Notes
Treat `auth-token.txt`, `cookie-dl.txt`, and copied request headers like passwords. Do not share them and do not commit them to version control.
This repository's `.gitignore` already ignores common token, cookie, header, PDF, and downloaded-page files.
download_kramerius_pdf.py
+745
View File
@@ -0,0 +1,745 @@
#!/usr/bin/env python3
"""Download Kramerius page images and assemble them into a PDF.
Default target:
https://www.digitalniknihovna.cz/mzk/view/uuid:0abf59c0-794e-11e4-8ce5-005056827e52
The script uses the same public Kramerius 7 APIs as the web viewer:
1. discover child page UUIDs through the search endpoint
2. download each page from the item image endpoint
3. embed the JPEGs directly into a PDF
"""
from __future__ import annotations
import argparse
import http.cookiejar
import json
import re
import sys
import time
import urllib.error
import urllib.parse
import urllib.request
from dataclasses import dataclass
from pathlib import Path
DEFAULT_URL = (
"https://www.digitalniknihovna.cz/mzk/view/"
"uuid:0abf59c0-794e-11e4-8ce5-005056827e52"
"?page=uuid:e57e2820-8547-11e4-a321-5ef3fc9bb22f"
)
KRAMERIUS_BASES = {
"mzk": "https://api.kramerius.mzk.cz",
}
DEFAULT_CLIENT_IDS = {
"mzk": "www.digitalniknihovna.cz",
}
USER_AGENT = "Mozilla/5.0 (compatible; kramerius-pdf-downloader/1.0)"
@dataclass(frozen=True)
class Page:
index: int
pid: str
label: str
@dataclass(frozen=True)
class JpegInfo:
width: int
height: int
components: int
@dataclass(frozen=True)
class LibraryConfig:
code: str
base_url: str
version: int
client_id: str | None
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(
description="Download all page images from a Kramerius document and create a PDF."
)
parser.add_argument(
"url",
nargs="?",
default=DEFAULT_URL,
help="Viewer URL, document UUID, or page/document URL from digitalniknihovna.cz.",
)
parser.add_argument("--library", default=None, help="Library code, e.g. mzk.")
parser.add_argument(
"--base-url",
default=None,
help="Kramerius API base URL. Defaults from --library when known.",
)
parser.add_argument(
"--output-dir",
default="downloaded_pages",
help="Directory where images will be stored.",
)
parser.add_argument(
"--pdf",
default="kramerius_download.pdf",
help="Output PDF path.",
)
parser.add_argument(
"--limit",
type=int,
default=None,
help="Download only the first N pages, useful for testing.",
)
parser.add_argument(
"--delay",
type=float,
default=0.2,
help="Seconds to wait between page downloads.",
)
parser.add_argument(
"--retries",
type=int,
default=3,
help="Download retries per request.",
)
parser.add_argument(
"--overwrite",
action="store_true",
help="Redownload images that already exist.",
)
parser.add_argument(
"--cookies",
default=None,
help=(
"Cookie file to use for authenticated downloads. Supports Netscape "
"cookies.txt exports and plain Cookie header text."
),
)
parser.add_argument(
"--auth-token",
default=None,
help=(
"Kramerius auth token. The script sends it as "
"Authorization: Bearer <token>."
),
)
parser.add_argument(
"--auth-file",
default=None,
help=(
"File containing either a raw token, an Authorization header, or "
"copied request headers from browser devtools."
),
)
parser.add_argument(
"--client",
default=None,
help="Value for the Kramerius Client header.",
)
return parser.parse_args()
def parse_viewer_input(value: str) -> tuple[str | None, str]:
"""Return (library_code, document_pid)."""
parsed = urllib.parse.urlparse(value)
if parsed.scheme and parsed.netloc:
path_parts = [part for part in parsed.path.split("/") if part]
library = path_parts[0] if path_parts else None
view_uuid = None
if "view" in path_parts:
view_index = path_parts.index("view")
if len(path_parts) > view_index + 1:
view_uuid = urllib.parse.unquote(path_parts[view_index + 1])
if view_uuid:
return library, normalize_pid(view_uuid)
match = re.search(r"uuid:[0-9a-fA-F-]{36}", value)
if match:
return library, normalize_pid(match.group(0))
return None, normalize_pid(value)
def normalize_pid(value: str) -> str:
value = urllib.parse.unquote(value.strip())
match = re.search(r"uuid:[0-9a-fA-F-]{36}", value)
if match:
return match.group(0)
match = re.search(r"[0-9a-fA-F]{8}(?:-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}", value)
if match:
return "uuid:" + match.group(0)
raise ValueError(f"Could not find a UUID in: {value}")
def resolve_library_config(
opener: urllib.request.OpenerDirector,
library: str,
explicit_base_url: str | None,
retries: int,
) -> LibraryConfig:
if explicit_base_url:
return LibraryConfig(
code=library,
base_url=explicit_base_url.rstrip("/"),
version=7,
client_id=DEFAULT_CLIENT_IDS.get(library),
)
if library in KRAMERIUS_BASES:
return LibraryConfig(
code=library,
base_url=KRAMERIUS_BASES[library],
version=7,
client_id=DEFAULT_CLIENT_IDS.get(library),
)
try:
config = fetch_digitalniknihovna_config(opener, library, retries)
except RuntimeError as exc:
raise SystemExit(
f"Could not resolve library {library!r} from digitalniknihovna.cz. "
"Pass --base-url explicitly.\n"
f"Reason: {exc}"
) from exc
return config
def fetch_digitalniknihovna_config(
opener: urllib.request.OpenerDirector, library: str, retries: int
) -> LibraryConfig:
url = "https://www.digitalniknihovna.cz/assets/shared/globals.js"
data, content_type = request_bytes(opener, url, retries)
if "javascript" not in content_type.lower() and "text" not in content_type.lower():
raise RuntimeError(f"Expected JavaScript config, got {content_type or 'unknown'}")
text = data.decode("utf-8", errors="replace")
block = find_library_config_block(text, library)
if block is None:
raise RuntimeError(f"Library code {library!r} was not found in globals.js")
base_url = extract_js_string_property(block, "url")
if not base_url:
raise RuntimeError(f"Library code {library!r} has no API URL in globals.js")
version = extract_js_int_property(block, "version") or 7
client_id = extract_js_string_property(block, "ga4clientId") or DEFAULT_CLIENT_IDS.get(library)
return LibraryConfig(
code=library,
base_url=base_url.rstrip("/"),
version=version,
client_id=client_id,
)
def find_library_config_block(text: str, library: str) -> str | None:
code_pattern = re.compile(rf"\bcode\s*:\s*['\"]{re.escape(library)}['\"]")
match = code_pattern.search(text)
if not match:
return None
start = text.rfind("{", 0, match.start())
if start == -1:
return None
depth = 0
quote: str | None = None
escaped = False
for index in range(start, len(text)):
char = text[index]
if quote:
if escaped:
escaped = False
elif char == "\\":
escaped = True
elif char == quote:
quote = None
continue
if char in {"'", '"'}:
quote = char
elif char == "{":
depth += 1
elif char == "}":
depth -= 1
if depth == 0:
return text[start : index + 1]
return None
def extract_js_string_property(block: str, name: str) -> str | None:
pattern = re.compile(rf"\b{re.escape(name)}\s*:\s*(['\"])(.*?)\1", re.S)
match = pattern.search(block)
return match.group(2) if match else None
def extract_js_int_property(block: str, name: str) -> int | None:
pattern = re.compile(rf"\b{re.escape(name)}\s*:\s*(\d+)")
match = pattern.search(block)
return int(match.group(1)) if match else None
def build_opener(
cookie_path: str | None,
) -> tuple[urllib.request.OpenerDirector, int, list[str]]:
if not cookie_path:
return urllib.request.build_opener(), 0, []
path = Path(cookie_path)
if not path.exists():
raise FileNotFoundError(f"Cookie file not found: {path}")
cookie_jar = http.cookiejar.MozillaCookieJar()
cookie_count = 0
try:
cookie_jar.load(path, ignore_discard=True, ignore_expires=True)
cookie_count = len(cookie_jar)
except (http.cookiejar.LoadError, OSError):
raw_cookie = parse_raw_cookie_file(path)
if raw_cookie:
opener = urllib.request.build_opener(RawCookieProcessor(raw_cookie))
return opener, len([part for part in raw_cookie.split(";") if part.strip()]), ["*"]
raise
domains = sorted({cookie.domain for cookie in cookie_jar})
return urllib.request.build_opener(urllib.request.HTTPCookieProcessor(cookie_jar)), cookie_count, domains
def cookie_domains_match_host(domains: list[str], host: str) -> bool:
if "*" in domains:
return True
host = host.lower()
for domain in domains:
domain = domain.lower().lstrip(".")
if host == domain or host.endswith("." + domain):
return True
return False
def parse_raw_cookie_file(path: Path) -> str:
lines = []
for line in path.read_text(encoding="utf-8").splitlines():
line = line.strip()
if not line or line.startswith("#"):
continue
if line.lower().startswith("cookie:"):
line = line.split(":", 1)[1].strip()
lines.append(line)
return "; ".join(lines)
class RawCookieProcessor(urllib.request.BaseHandler):
def __init__(self, cookie_header: str) -> None:
self.cookie_header = cookie_header
def http_request(self, request: urllib.request.Request) -> urllib.request.Request:
request.add_unredirected_header("Cookie", self.cookie_header)
return request
https_request = http_request
class StaticHeaderProcessor(urllib.request.BaseHandler):
def __init__(self, headers: dict[str, str]) -> None:
self.headers = headers
def http_request(self, request: urllib.request.Request) -> urllib.request.Request:
for key, value in self.headers.items():
request.add_unredirected_header(key, value)
return request
https_request = http_request
def parse_auth_file(path: str) -> dict[str, str]:
text = Path(path).read_text(encoding="utf-8").strip()
if not text:
return {}
headers: dict[str, str] = {}
for line in text.splitlines():
line = line.strip()
if not line or line.startswith("#"):
continue
if ":" not in line:
continue
key, value = line.split(":", 1)
key = key.strip()
value = value.strip()
if key.lower() in {"authorization", "client"} and value:
headers[header_display_name(key)] = value
if headers:
return headers
token = text
if token.lower().startswith("bearer "):
token = token.split(None, 1)[1].strip()
return {"Authorization": f"Bearer {token}"}
def header_display_name(key: str) -> str:
lower = key.lower()
if lower == "authorization":
return "Authorization"
if lower == "client":
return "Client"
return key
def auth_headers(auth_token: str | None, auth_file: str | None, client: str | None) -> dict[str, str]:
headers = parse_auth_file(auth_file) if auth_file else {}
if auth_token:
token = auth_token.strip()
if token.lower().startswith("bearer "):
headers["Authorization"] = token
else:
headers["Authorization"] = f"Bearer {token}"
if client:
headers["Client"] = client
return headers
def install_headers(
opener: urllib.request.OpenerDirector, headers: dict[str, str]
) -> urllib.request.OpenerDirector:
if not headers:
return opener
opener.add_handler(StaticHeaderProcessor(headers))
return opener
def request_bytes(
opener: urllib.request.OpenerDirector, url: str, retries: int
) -> tuple[bytes, str]:
headers = {"User-Agent": USER_AGENT, "Accept": "*/*"}
last_error: Exception | None = None
for attempt in range(1, retries + 1):
request = urllib.request.Request(url, headers=headers)
try:
with opener.open(request, timeout=60) as response:
content_type = response.headers.get("Content-Type", "")
return response.read(), content_type
except (urllib.error.URLError, TimeoutError) as exc:
last_error = exc
if attempt < retries:
time.sleep(min(2**attempt, 10))
raise RuntimeError(f"Failed to fetch {url}: {last_error}")
def request_json(opener: urllib.request.OpenerDirector, url: str, retries: int) -> dict:
data, content_type = request_bytes(opener, url, retries)
if "json" not in content_type.lower():
raise RuntimeError(f"Expected JSON from {url}, got {content_type or 'unknown'}")
return json.loads(data.decode("utf-8"))
def discover_pages(
opener: urllib.request.OpenerDirector, config: LibraryConfig, document_pid: str, retries: int
) -> list[Page]:
if config.version >= 7:
query = {
"fl": "pid,accessibility,model,title.search,page.type,page.number,page.placement",
"q": f'own_parent.pid:"{document_pid}"',
"sort": "rels_ext_index.sort asc",
"rows": "10000",
"wt": "json",
}
pid_field = "pid"
label_fields = ("page.number", "title.search")
else:
query = {
"fl": "PID,dostupnost,fedora.model,dc.title",
"q": f'parent_pid:"{document_pid}"',
"sort": "rels_ext_index asc",
"rows": "10000",
"wt": "json",
}
pid_field = "PID"
label_fields = ("dc.title",)
url = f"{api_url(config)}/search?{urllib.parse.urlencode(query)}"
payload = request_json(opener, url, retries)
docs = payload.get("response", {}).get("docs", [])
pages: list[Page] = []
for index, doc in enumerate(docs, start=1):
pid = doc.get(pid_field)
if not pid:
continue
label = next((doc.get(field) for field in label_fields if doc.get(field)), str(index))
pages.append(Page(index=index, pid=pid, label=str(label)))
if not pages:
raise RuntimeError(f"No pages found for {document_pid}. Search URL was: {url}")
return pages
def api_url(config: LibraryConfig) -> str:
if config.version >= 7:
return f"{config.base_url}/search/api/client/v7.0"
return f"{config.base_url}/search/api/v5.0"
def page_image_url(config: LibraryConfig, pid: str) -> str:
encoded_pid = urllib.parse.quote(pid, safe=":")
if config.version >= 7:
return f"{api_url(config)}/items/{encoded_pid}/image"
return f"{api_url(config)}/item/{encoded_pid}/streams/IMG_FULL"
def download_pages(
opener: urllib.request.OpenerDirector,
config: LibraryConfig,
pages: list[Page],
output_dir: Path,
retries: int,
delay: float,
overwrite: bool,
) -> list[Path]:
output_dir.mkdir(parents=True, exist_ok=True)
paths: list[Path] = []
for page in pages:
path = output_dir / f"{page.index:04d}.jpg"
paths.append(path)
if path.exists() and not overwrite:
print(f"[{page.index:03d}/{len(pages):03d}] exists {path}")
continue
url = page_image_url(config, page.pid)
data, content_type = request_bytes(opener, url, retries)
if "image" not in content_type.lower():
preview = data[:200].decode("utf-8", errors="replace")
raise RuntimeError(
f"Expected image for {page.pid}, got {content_type or 'unknown'}.\n"
f"Response starts with: {preview}"
)
path.write_bytes(data)
print(f"[{page.index:03d}/{len(pages):03d}] saved {path} ({len(data) // 1024} KiB)")
if delay > 0:
time.sleep(delay)
return paths
def read_jpeg_info(data: bytes) -> JpegInfo:
if not data.startswith(b"\xff\xd8"):
raise ValueError("Not a JPEG file")
offset = 2
while offset < len(data):
while offset < len(data) and data[offset] == 0xFF:
offset += 1
if offset >= len(data):
break
marker = data[offset]
offset += 1
if marker in {0xD8, 0xD9}:
continue
if offset + 2 > len(data):
break
segment_length = int.from_bytes(data[offset : offset + 2], "big")
if segment_length < 2 or offset + segment_length > len(data):
break
if marker in {
0xC0,
0xC1,
0xC2,
0xC3,
0xC5,
0xC6,
0xC7,
0xC9,
0xCA,
0xCB,
0xCD,
0xCE,
0xCF,
}:
if segment_length < 8:
break
height = int.from_bytes(data[offset + 3 : offset + 5], "big")
width = int.from_bytes(data[offset + 5 : offset + 7], "big")
components = data[offset + 7]
return JpegInfo(width=width, height=height, components=components)
offset += segment_length
raise ValueError("Could not find JPEG dimensions")
def pdf_escape(value: str) -> str:
return value.replace("\\", "\\\\").replace("(", "\\(").replace(")", "\\)")
def build_pdf(image_paths: list[Path], pdf_path: Path) -> None:
if not image_paths:
raise RuntimeError("No images to write to PDF")
objects: list[bytes] = []
def add_object(body: bytes) -> int:
objects.append(body)
return len(objects)
catalog_id = add_object(b"<< /Type /Catalog /Pages 2 0 R >>")
pages_id = add_object(b"")
page_ids: list[int] = []
for index, image_path in enumerate(image_paths, start=1):
image_data = image_path.read_bytes()
info = read_jpeg_info(image_data)
color_space = b"/DeviceRGB"
decode = b""
if info.components == 1:
color_space = b"/DeviceGray"
elif info.components == 4:
color_space = b"/DeviceCMYK"
decode = b" /Decode [1 0 1 0 1 0 1 0]"
image_id = len(objects) + 2
content_id = len(objects) + 3
page_id = add_object(
(
f"<< /Type /Page /Parent {pages_id} 0 R "
f"/MediaBox [0 0 {info.width} {info.height}] "
f"/Resources << /XObject << /Im{index} {image_id} 0 R >> >> "
f"/Contents {content_id} 0 R >>"
).encode("ascii")
)
page_ids.append(page_id)
image_header = (
f"<< /Type /XObject /Subtype /Image /Width {info.width} "
f"/Height {info.height} /ColorSpace {color_space.decode('ascii')} "
f"/BitsPerComponent 8 /Filter /DCTDecode{decode.decode('ascii')} "
f"/Length {len(image_data)} >>\nstream\n"
).encode("ascii")
add_object(image_header + image_data + b"\nendstream")
content = f"q\n{info.width} 0 0 {info.height} 0 0 cm\n/Im{index} Do\nQ\n".encode(
"ascii"
)
add_object(
b"<< /Length "
+ str(len(content)).encode("ascii")
+ b" >>\nstream\n"
+ content
+ b"endstream"
)
kids = " ".join(f"{page_id} 0 R" for page_id in page_ids)
objects[pages_id - 1] = (
f"<< /Type /Pages /Count {len(page_ids)} /Kids [{kids}] >>"
).encode("ascii")
metadata = f"<< /Producer ({pdf_escape(Path(sys.argv[0]).name)}) >>".encode("ascii")
info_id = add_object(metadata)
pdf_path.parent.mkdir(parents=True, exist_ok=True)
with pdf_path.open("wb") as handle:
handle.write(b"%PDF-1.4\n%\xe2\xe3\xcf\xd3\n")
offsets = [0]
for object_id, body in enumerate(objects, start=1):
offsets.append(handle.tell())
handle.write(f"{object_id} 0 obj\n".encode("ascii"))
handle.write(body)
handle.write(b"\nendobj\n")
xref_offset = handle.tell()
handle.write(f"xref\n0 {len(objects) + 1}\n".encode("ascii"))
handle.write(b"0000000000 65535 f \n")
for offset in offsets[1:]:
handle.write(f"{offset:010d} 00000 n \n".encode("ascii"))
handle.write(
(
f"trailer\n<< /Size {len(objects) + 1} "
f"/Root {catalog_id} 0 R /Info {info_id} 0 R >>\n"
f"startxref\n{xref_offset}\n%%EOF\n"
).encode("ascii")
)
def main() -> int:
args = parse_args()
library_from_url, document_pid = parse_viewer_input(args.url)
library = args.library or library_from_url or "mzk"
opener, cookie_count, cookie_domains = build_opener(args.cookies)
config = resolve_library_config(opener, library, args.base_url, args.retries)
print(f"Library: {config.code}")
print(f"API: {config.base_url} (Kramerius {config.version})")
print(f"Document: {document_pid}")
client = args.client or config.client_id
headers = auth_headers(
args.auth_token,
args.auth_file,
client if (args.auth_token or args.auth_file) else None,
)
opener = install_headers(opener, headers)
if args.cookies:
if cookie_count:
print(f"Loaded {cookie_count} cookies from {args.cookies}")
api_host = urllib.parse.urlparse(config.base_url).hostname or ""
if not cookie_domains_match_host(cookie_domains, api_host):
print(
"Warning: cookie domains do not match the API host "
f"{api_host}; these cookies probably will not authenticate downloads."
)
else:
print(f"Warning: loaded 0 cookies from {args.cookies}")
if "Authorization" in headers:
print("Using Authorization bearer token")
if "Client" in headers:
print(f"Using Client header: {headers['Client']}")
print("Discovering pages...")
pages = discover_pages(opener, config, document_pid, args.retries)
if args.limit:
pages = pages[: args.limit]
print(f"Found {len(pages)} pages")
image_paths = download_pages(
opener=opener,
config=config,
pages=pages,
output_dir=Path(args.output_dir),
retries=args.retries,
delay=args.delay,
overwrite=args.overwrite,
)
print(f"Writing PDF: {args.pdf}")
build_pdf(image_paths, Path(args.pdf))
print("Done")
return 0
if __name__ == "__main__":
raise SystemExit(main())