trovenps 0.4.0__py3-none-any.whl

nps/__init__.py

@@ -0,0 +1,10 @@
+"""Trove — a NoPayStation catalog browser & downloader."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("trovenps")
+except PackageNotFoundError:  # running from a source tree that isn't installed
+    __version__ = "0.0.0"
+
+__all__ = ["__version__"]

nps/__main__.py

@@ -0,0 +1,6 @@
+"""``python -m nps`` -> the command-line interface."""
+
+from .cli import main
+
+if __name__ == "__main__":
+    main()

nps/aria2.py

@@ -0,0 +1,98 @@
+"""aria2 hand-off: write an input file, run a local aria2c, or push over RPC."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+import httpx
+from loguru import logger
+
+from . import monitoring
+from .models import Game
+
+
+def write_aria2_input(games: list[Game], output_dir: Path, dest: Path) -> int:
+    """Write an aria2 ``--input-file`` (``aria2c -c -i <dest>``); return entry count."""
+    targets = [g for g in games if g.downloadable]
+    lines: list[str] = []
+    for g in targets:
+        lines.append(g.download_url)
+        lines.append(f"  out={g.filename}")
+        lines.append(f"  dir={output_dir}")
+        if g.sha256:
+            lines.append(f"  checksum=sha-256={g.sha256.lower()}")
+    dest.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    return len(targets)
+
+
+def run_aria2c(games: list[Game], output_dir: Path, *, concurrency: int = 3) -> int:
+    """Download matches now with a local ``aria2c`` (single command).
+
+    Writes a temporary input file and hands it to ``aria2c -c``; aria2c streams
+    its own progress and verifies the embedded SHA-256 checksums. Returns aria2c's
+    exit code. Raises ``FileNotFoundError`` if ``aria2c`` isn't on PATH.
+    """
+    aria2c = shutil.which("aria2c")
+    if aria2c is None:
+        raise FileNotFoundError(
+            "aria2c not found on PATH; install aria2, or use --aria2 FILE to export an input file."
+        )
+    with tempfile.NamedTemporaryFile("w", suffix=".aria2.txt", delete=False, encoding="utf-8") as fh:
+        tmp = Path(fh.name)
+    try:
+        count = write_aria2_input(games, output_dir, tmp)
+        logger.info("Handing {} download(s) to aria2c (-j{}).", count, concurrency)
+        return subprocess.run([aria2c, "-c", f"-j{concurrency}", "-i", str(tmp)]).returncode
+    finally:
+        tmp.unlink(missing_ok=True)
+
+
+async def add_to_aria2_rpc(
+    games: list[Game],
+    rpc_url: str,
+    *,
+    secret: str | None = None,
+    remote_dir: str | None = None,
+    client: httpx.AsyncClient | None = None,
+) -> list[str]:
+    """Queue downloads on a running aria2 daemon; return the assigned GIDs.
+
+    ``remote_dir`` is a path on the aria2 host; omit it for the daemon's default.
+    """
+    targets = [g for g in games if g.downloadable]
+    owns_client = client is None
+    client = client or httpx.AsyncClient(timeout=httpx.Timeout(30.0))
+    gids: list[str] = []
+    try:
+        for g in targets:
+            options: dict[str, str] = {"out": g.filename, "continue": "true"}
+            if remote_dir is not None:
+                options["dir"] = remote_dir
+            if g.sha256:
+                options["checksum"] = f"sha-256={g.sha256.lower()}"
+
+            params: list = []  # aria2.addUri params: [secret?, [uris], options]
+            if secret:
+                params.append(f"token:{secret}")
+            params.append([g.download_url])
+            params.append(options)
+            payload = {"jsonrpc": "2.0", "id": g.title_id, "method": "aria2.addUri", "params": params}
+            try:
+                resp = await client.post(rpc_url, json=payload)
+                resp.raise_for_status()
+                data = resp.json()
+                if "error" in data:
+                    logger.error("aria2 rejected {}: {}", g.title_id, data["error"])
+                    continue
+                gids.append(data["result"])
+                logger.info("Queued {} ({}) -> aria2 gid {}", g.title_id, g.name, data["result"])
+            except Exception as exc:
+                monitoring.capture_exception(exc)
+                logger.error("Failed to queue {} ({}): {}", g.title_id, g.name, exc)
+    finally:
+        if owns_client:
+            await client.aclose()
+    return gids

nps/catalog.py

@@ -0,0 +1,195 @@
+"""Remote NoPayStation catalog: fetch TSVs (cached), parse into ``Game`` records.
+
+Datasets are cached for ``CACHE_TTL``; once stale they're revalidated with an
+ETag conditional request, so an unchanged dataset costs a ``304``, not a refetch.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import csv
+import json
+import os
+import time
+from datetime import timedelta
+from pathlib import Path
+
+import httpx
+from loguru import logger
+from platformdirs import user_cache_dir
+from pydantic import ValidationError
+
+from .models import COLUMNS, ContentType, Game, Platform
+
+BASE_URL = "https://nopaystation.com/tsv"
+CACHE_TTL = timedelta(days=30).total_seconds()
+# Default to the OS cache dir (shared across runs, outside the repo); override
+# with NPS_CACHE_DIR for a fixed location.
+CACHE_DIR = Path(os.getenv("NPS_CACHE_DIR") or user_cache_dir("nps"))
+
+# NoPayStation doesn't publish every platform×type combination.
+DATASETS: dict[Platform, tuple[ContentType, ...]] = {
+    Platform.PSV: (
+        ContentType.GAMES,
+        ContentType.DLCS,
+        ContentType.THEMES,
+        ContentType.UPDATES,
+        ContentType.DEMOS,
+    ),
+    Platform.PSP: (ContentType.GAMES, ContentType.DLCS),
+    Platform.PS3: (
+        ContentType.GAMES,
+        ContentType.DLCS,
+        ContentType.THEMES,
+        ContentType.AVATARS,
+    ),
+    Platform.PSX: (ContentType.GAMES,),
+    Platform.PSM: (ContentType.GAMES,),
+}
+
+
+def dataset_name(platform: Platform, content_type: ContentType) -> str:
+    return f"{platform.value}_{content_type.value}"
+
+
+def _paths(name: str) -> tuple[Path, Path]:
+    return CACHE_DIR / f"{name}.tsv", CACHE_DIR / f"{name}.meta.json"
+
+
+def reset_cache() -> int:
+    """Delete every cached dataset; return the number of files removed."""
+    if not CACHE_DIR.exists():
+        return 0
+    removed = 0
+    for path in CACHE_DIR.glob("*"):
+        path.unlink()
+        removed += 1
+    return removed
+
+
+def _load_meta(meta_path: Path) -> dict:
+    try:
+        return json.loads(meta_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+
+def _is_fresh(meta: dict) -> bool:
+    fetched_at = meta.get("fetched_at")
+    return isinstance(fetched_at, (int, float)) and (time.time() - fetched_at) < CACHE_TTL
+
+
+async def fetch_dataset(
+    platform: Platform,
+    content_type: ContentType,
+    *,
+    client: httpx.AsyncClient | None = None,
+    refresh: bool = False,
+    offline: bool = False,
+) -> Path | None:
+    """Path to the cached TSV, fetching/revalidating as needed.
+
+    ``None`` if it can't be obtained (invalid combo, or offline/network failure
+    with no cached fallback).
+    """
+    name = dataset_name(platform, content_type)
+    tsv_path, meta_path = _paths(name)
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+    if offline:
+        return tsv_path if tsv_path.exists() else None
+
+    meta = _load_meta(meta_path)
+    if tsv_path.exists() and not refresh and _is_fresh(meta):
+        return tsv_path
+
+    headers: dict[str, str] = {}
+    if tsv_path.exists() and not refresh and meta.get("etag"):
+        headers["If-None-Match"] = meta["etag"]
+
+    url = f"{BASE_URL}/{name}.tsv"
+    owns_client = client is None
+    client = client or httpx.AsyncClient(timeout=httpx.Timeout(30.0, read=120.0))
+    try:
+        resp = await client.get(url, headers=headers, follow_redirects=True)
+        if resp.status_code == 304:
+            meta["fetched_at"] = time.time()
+            meta_path.write_text(json.dumps(meta), encoding="utf-8")
+            return tsv_path
+        resp.raise_for_status()
+        body = resp.content
+        if not body.startswith(b"Title ID\t"):  # an error page, not a dataset
+            logger.warning("{} is not a valid dataset; skipping.", name)
+            return None
+        tsv_path.write_bytes(body)
+        meta_path.write_text(
+            json.dumps(
+                {
+                    "etag": resp.headers.get("ETag"),
+                    "last_modified": resp.headers.get("Last-Modified"),
+                    "fetched_at": time.time(),
+                }
+            ),
+            encoding="utf-8",
+        )
+        logger.info("Fetched {} ({:,} bytes).", name, len(body))
+        return tsv_path
+    except httpx.HTTPError as exc:
+        if tsv_path.exists():
+            logger.warning("Fetch failed for {} ({}); using cached copy.", name, exc)
+            return tsv_path
+        logger.error("Fetch failed for {} and no cache available: {}", name, exc)
+        return None
+    finally:
+        if owns_client:
+            await client.aclose()
+
+
+def _dedupe(games: list[Game]) -> list[Game]:
+    """Collapse rows sharing an identity, preferring a downloadable variant."""
+    best: dict[str, Game] = {}
+    for g in games:
+        existing = best.get(g.identity)
+        if existing is None or (g.downloadable and not existing.downloadable):
+            best[g.identity] = g
+    return list(best.values())
+
+
+def parse_tsv(path: Path, platform: Platform, content_type: ContentType) -> list[Game]:
+    games: list[Game] = []
+    skipped = 0
+    with path.open(encoding="utf-8", newline="") as fh:
+        for row in csv.DictReader(fh, delimiter="\t"):
+            data: dict[str, object] = {}
+            for header, field in COLUMNS.items():
+                if value := row.get(header):
+                    data.setdefault(field, value)  # first non-empty wins
+            if not data.get("title_id"):
+                continue
+            data["platform"] = platform
+            data["content_type"] = content_type
+            try:
+                games.append(Game.model_validate(data))
+            except ValidationError:
+                skipped += 1
+    if skipped:
+        logger.warning("Skipped {} malformed row(s) in {}.", skipped, dataset_name(platform, content_type))
+    return games
+
+
+async def load_games(
+    platform: Platform,
+    content_type: ContentType,
+    *,
+    client: httpx.AsyncClient | None = None,
+    refresh: bool = False,
+    offline: bool = False,
+) -> list[Game]:
+    """Fetch (cached) and parse a single dataset."""
+    path = await fetch_dataset(
+        platform, content_type, client=client, refresh=refresh, offline=offline
+    )
+    if path is None:
+        return []
+    games = await asyncio.to_thread(parse_tsv, path, platform, content_type)
+    return _dedupe(games)

nps/cli.py

@@ -0,0 +1,172 @@
+"""Command-line interface for the nps catalog downloader."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import os
+from pathlib import Path
+
+from loguru import logger
+
+from . import __version__
+from .aria2 import add_to_aria2_rpc, run_aria2c, write_aria2_input
+from .catalog import load_games, reset_cache
+from .download import download_games
+from .models import ContentType, Filter, Game, Platform
+
+_SIZE_UNITS = {"B": 1, "KB": 1024, "MB": 1024**2, "GB": 1024**3, "TB": 1024**4}
+
+
+def parse_size(text: str) -> int:
+    """Parse a size like ``2GB``, ``500MB``, or a raw byte count into bytes."""
+    s = text.strip().upper()
+    for unit in ("TB", "GB", "MB", "KB", "B"):
+        if s.endswith(unit):
+            return int(float(s[: -len(unit)].strip()) * _SIZE_UNITS[unit])
+    return int(s)  # bare number = bytes
+
+
+def _game_json(g: Game) -> dict[str, object]:
+    """A flat, agent-friendly view of a game (stable keys, no internal model noise)."""
+    return {
+        "title_id": g.title_id,
+        "name": g.name,
+        "region": g.region,
+        "platform": g.platform.value if g.platform else None,
+        "content_type": g.content_type.value if g.content_type else None,
+        "content_subtype": g.content_subtype,
+        "downloadable": g.downloadable,
+        "url": g.download_url if g.downloadable else None,
+        "file_size": g.file_size,
+        "sha256": g.sha256,
+        "required_fw": g.required_fw,
+        "content_id": g.content_id,
+        "last_modification_date": g.last_modification_date,
+    }
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="nps", description="Trove — browse and download from NoPayStation."
+    )
+    p.add_argument("query", nargs="?", help="Filter by Title ID or name (case-insensitive).")
+    p.add_argument("-p", "--platform", type=Platform, choices=list(Platform), default=Platform.PSV,
+                   help="Console platform (default: PSV).")
+    p.add_argument("-t", "--type", type=ContentType, choices=list(ContentType), default=ContentType.GAMES,
+                   dest="content_type", help="Content type (default: GAMES).")
+    p.add_argument("-r", "--region", action="append", help="Region to include (repeatable), e.g. US EU JP.")
+    p.add_argument("--name", help="Filter by name substring only (case-insensitive).")
+    p.add_argument("--title-id", dest="title_id", help="Filter by Title ID substring only.")
+    p.add_argument("--max-fw", type=float, metavar="VERSION",
+                   help="Only items requiring firmware <= VERSION (e.g. 3.60).")
+    p.add_argument("--min-size", type=parse_size, metavar="SIZE",
+                   help="Only items at least SIZE (e.g. 100MB, 2GB).")
+    p.add_argument("--max-size", type=parse_size, metavar="SIZE",
+                   help="Only items at most SIZE (e.g. 500MB, 4GB).")
+    p.add_argument("-o", "--output", type=Path, default=Path("downloads"), help="Output directory.")
+    p.add_argument("-l", "--list", action="store_true", help="List matches without downloading.")
+    p.add_argument("--json", action="store_true",
+                   help="Print matches as JSON (no download); for scripts and agents.")
+    p.add_argument("-a", "--all", action="store_true", help="Download every downloadable match.")
+    p.add_argument("-c", "--concurrency", type=int, default=3, help="Max concurrent downloads.")
+    p.add_argument("--no-verify", action="store_true", help="Skip SHA256 verification.")
+    p.add_argument("--refresh", action="store_true", help="Force-refresh the catalog from NoPayStation.")
+    p.add_argument("--reset-cache", action="store_true", help="Delete all cached catalogs and exit.")
+    p.add_argument("--offline", action="store_true", help="Use only the cached catalog (no network).")
+    p.add_argument("--aria2", type=Path, metavar="FILE", help="Export matches as an aria2 input file.")
+    p.add_argument("--aria2-run", action="store_true",
+                   help="Download matches now via a local aria2c (single command; needs aria2c on PATH).")
+    p.add_argument("--aria2-rpc", nargs="?", const=os.getenv("ARIA2_RPC_URL"), metavar="URL",
+                   help="Push matches to a running aria2 daemon (URL or ARIA2_RPC_URL env).")
+    p.add_argument("--aria2-secret", default=os.getenv("ARIA2_RPC_SECRET"),
+                   help="aria2 RPC secret token (or ARIA2_RPC_SECRET env).")
+    p.add_argument("--aria2-dir", help="Download dir on the aria2 host (RPC mode).")
+    p.add_argument("--version", action="version", version=f"nps {__version__}")
+    return p
+
+
+def main(argv: list[str] | None = None) -> None:
+    from .observability import setup
+
+    args = _build_parser().parse_args(argv)
+    # In --json mode, logs (loguru -> tqdm.write -> stdout) would corrupt the
+    # payload, so silence the console sink and let stdout carry JSON alone.
+    setup(console=not args.json)
+
+    if args.reset_cache:
+        logger.info("Removed {} cached file(s).", reset_cache())
+        return
+
+    games = asyncio.run(
+        load_games(args.platform, args.content_type, refresh=args.refresh, offline=args.offline)
+    )
+    if not games:
+        if args.json:
+            print("[]")
+            return
+        logger.warning("No catalog data for {} {}.", args.platform.value, args.content_type.value)
+        return
+
+    fkw: dict[str, object] = dict(
+        query=args.query,
+        title_id=args.title_id,
+        name=args.name,
+        regions=set(args.region) if args.region else None,
+        max_fw=args.max_fw,
+        min_size=args.min_size,
+        max_size=args.max_size,
+    )
+    flt = Filter(**fkw)
+    matches = flt.apply(games)
+
+    if args.json or args.list or not (args.query or args.all):
+        shown = Filter(**fkw, downloadable_only=False).apply(games)
+        if args.json:
+            print(json.dumps([_game_json(g) for g in shown], indent=2))
+            return
+        print(f"{len(shown)} match(es), {len(matches)} downloadable:\n")
+        for g in shown:
+            mark = " " if g.downloadable else "x"
+            print(f"  [{mark}] {g.title_id}  {g.region:4}  {g.name}")
+        if not (args.query or args.all):
+            print("\nPass a Title ID / name, or use --all to download everything.")
+        return
+
+    if not matches:
+        logger.warning("No downloadable matches.")
+        return
+
+    if args.aria2:
+        count = write_aria2_input(matches, args.output, args.aria2)
+        logger.info("Wrote {} entries to {}", count, args.aria2)
+        logger.info("Run: aria2c -c -j{} -i {}", args.concurrency, args.aria2)
+        return
+
+    if args.aria2_run:
+        try:
+            run_aria2c(matches, args.output, concurrency=args.concurrency)
+        except FileNotFoundError as exc:
+            logger.error(str(exc))
+        return
+
+    if args.aria2_rpc:
+        gids = asyncio.run(
+            add_to_aria2_rpc(
+                matches, args.aria2_rpc, secret=args.aria2_secret, remote_dir=args.aria2_dir
+            )
+        )
+        logger.info("Queued {}/{} download(s) to aria2.", len(gids), len(matches))
+        return
+
+    logger.info(
+        "Downloading {} item(s) to {} (concurrency={})", len(matches), args.output, args.concurrency
+    )
+    asyncio.run(
+        download_games(matches, args.output, concurrency=args.concurrency, verify=not args.no_verify)
+    )
+
+
+if __name__ == "__main__":
+    main()

nps/download.py

@@ -0,0 +1,186 @@
+"""Async, resumable PKG downloader with Range resume, retry, and SHA256 verify."""
+
+from __future__ import annotations
+
+import asyncio
+import hashlib
+from pathlib import Path
+
+import httpx
+from loguru import logger
+
+from . import monitoring
+from .models import Game
+from .progress import ProgressSink, TqdmSink
+
+_RETRYABLE = (httpx.TransportError, httpx.TimeoutException)
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as fh:
+        for chunk in iter(lambda: fh.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _already_complete(game: Game, dest: Path, verify: bool) -> bool:
+    if not (dest.exists() and game.file_size and dest.stat().st_size == game.file_size):
+        return False
+    if not verify or not game.sha256:
+        return True
+    return _sha256(dest) == game.sha256.lower()
+
+
+async def _stream_attempt(
+    client: httpx.AsyncClient,
+    url: str,
+    tmp: Path,
+    *,
+    desc: str,
+    fallback_total: int,
+    sink: ProgressSink,
+    key: str,
+) -> None:
+    resume_from = tmp.stat().st_size if tmp.exists() else 0
+    headers = {"Range": f"bytes={resume_from}-"} if resume_from else {}
+
+    async with client.stream("GET", url, headers=headers, follow_redirects=True) as resp:
+        if resp.status_code == 416:  # already complete on the server side
+            return
+        if resume_from and resp.status_code == 200:  # Range ignored; restart clean
+            resume_from = 0
+        resp.raise_for_status()
+
+        if resp.status_code == 206:
+            content_range = resp.headers.get("Content-Range", "")
+            total = (
+                int(content_range.rsplit("/", 1)[-1])
+                if "/" in content_range
+                else resume_from + int(resp.headers.get("Content-Length", 0))
+            )
+        else:
+            total = int(resp.headers.get("Content-Length", 0)) or fallback_total
+
+        sink.start(key, desc, total or None, initial=resume_from)
+        with tmp.open("ab" if resume_from else "wb") as fh:
+            async for chunk in resp.aiter_bytes(chunk_size=1024 * 256):
+                fh.write(chunk)
+                sink.advance(key, len(chunk))
+
+
+async def download_game(
+    game: Game,
+    output_dir: Path,
+    *,
+    client: httpx.AsyncClient | None = None,
+    verify: bool = True,
+    sink: ProgressSink | None = None,
+    max_retries: int = 5,
+) -> Path:
+    url = game.download_url
+    output_dir.mkdir(parents=True, exist_ok=True)
+    dest = output_dir / game.filename
+    sink = sink if sink is not None else TqdmSink()
+    key = game.filename
+
+    if await asyncio.to_thread(_already_complete, game, dest, verify):
+        logger.info("Skipping {} (already downloaded)", game.name)
+        return dest
+
+    owns_client = client is None
+    client = client or httpx.AsyncClient(timeout=httpx.Timeout(30.0, read=300.0))
+    tmp = dest.with_suffix(dest.suffix + ".part")
+    fallback_total = game.file_size or 0
+
+    resume_bytes = tmp.stat().st_size if tmp.exists() else 0
+    monitoring.add_breadcrumb(
+        category="download",
+        message=("Resuming" if resume_bytes else "Starting") + f" {game.title_id}",
+        data={"resume_from": resume_bytes, "url": url},
+    )
+
+    try:
+        for attempt in range(1, max_retries + 1):
+            try:
+                await _stream_attempt(
+                    client, url, tmp, desc=game.name[:40],
+                    fallback_total=fallback_total, sink=sink, key=key,
+                )
+                break
+            except _RETRYABLE as exc:
+                if attempt == max_retries:
+                    raise
+                wait = min(2**attempt, 30)  # .part is kept, so the retry resumes
+                monitoring.add_breadcrumb(
+                    category="download",
+                    level="warning",
+                    message=f"{type(exc).__name__} on attempt {attempt}/{max_retries}, "
+                    f"retrying in {wait}s",
+                    data={"error": str(exc)},
+                )
+                logger.warning(
+                    "{}: {}, retrying in {}s ({}/{})...",
+                    game.title_id, type(exc).__name__, wait, attempt, max_retries,
+                )
+                await asyncio.sleep(wait)
+    finally:
+        sink.finish(key)
+        if owns_client:
+            await client.aclose()
+
+    # Re-hash from disk: an in-memory digest can't survive a cross-run resume.
+    if verify and game.sha256:
+        actual = await asyncio.to_thread(_sha256, tmp)
+        if actual != game.sha256.lower():
+            tmp.unlink(missing_ok=True)
+            raise ValueError(
+                f"SHA256 mismatch for {game.name}: expected {game.sha256}, got {actual}"
+            )
+
+    tmp.replace(dest)
+    return dest
+
+
+async def download_games(
+    games: list[Game],
+    output_dir: Path,
+    *,
+    concurrency: int = 3,
+    verify: bool = True,
+    sink: ProgressSink | None = None,
+) -> list[Path]:
+    """Download many games concurrently, capped at ``concurrency`` in flight."""
+    targets = [g for g in games if g.downloadable]
+    sink = sink if sink is not None else TqdmSink()
+    sem = asyncio.Semaphore(concurrency)
+    results: list[Path] = []
+
+    async with httpx.AsyncClient(timeout=httpx.Timeout(30.0, read=300.0)) as client:
+
+        async def worker(game: Game) -> None:
+            async with sem:
+                with monitoring.isolation_scope() as scope:
+                    scope.set_tag("title_id", game.title_id)
+                    scope.set_tag("region", game.region)
+                    scope.set_context(
+                        "game",
+                        {
+                            "title_id": game.title_id,
+                            "name": game.name,
+                            "region": game.region,
+                            "url": game.pkg_direct_link,
+                            "file_size": game.file_size,
+                        },
+                    )
+                    try:
+                        results.append(
+                            await download_game(game, output_dir, client=client, verify=verify, sink=sink)
+                        )
+                    except Exception as exc:  # report every failure, but keep going
+                        monitoring.capture_exception(exc)
+                        logger.error("Failed {} ({}): {}", game.title_id, game.name, exc)
+
+        await asyncio.gather(*(worker(g) for g in targets))
+
+    return results