bppicker 0.1.0__py3-none-any.whl

bpp/__init__.py

@@ -0,0 +1,26 @@
+"""Best Photo Picker: Local-first photo curation tool."""
+
+# Cap OpenCV's decode size before cv2 is imported anywhere. OpenCV reads
+# OPENCV_IO_MAX_IMAGE_PIXELS once at C-extension load time, so it MUST be
+# set before the first `import cv2` in the process — this package __init__
+# runs before any `bpp.*` submodule (and thus before their cv2 imports),
+# in the server, the CLI, and every multiprocessing-spawn child. Without
+# this, the PIL MAX_IMAGE_PIXELS pin in bpp/scoring/aggregate.py does NOT
+# protect the cv2 decode path (cv2.imread is tried first), leaving a
+# decompression-bomb hole: a valid ~50000x50000 image decodes fine in cv2 and
+# OOMs the analyze/phash worker. 200M matches the PIL pin.
+import os as _os
+
+_os.environ.setdefault("OPENCV_IO_MAX_IMAGE_PIXELS", str(200_000_000))
+
+__version__ = "0.1.0"
+APP_NAME = "Best Photo Picker"
+
+# Eagerly import the model registry so the Batch-3 download chokepoint
+# (item 18 of the legal-posture rollout) installs before any BPP code
+# can import a third-party package with auto-download behavior. The
+# chokepoint patches the upstream downloader if the package is
+# already loaded, and registers a meta-path hook for packages loaded
+# later. Importing it from the top-level bpp package ensures any
+# ``from bpp...`` import path triggers installation.
+import bpp.registry  # noqa: E402, F401  — side-effecting import

bpp/ai/__init__.py

@@ -0,0 +1 @@
+"""AI-powered photo editing tools (optional dependencies)."""

bpp/ai/inpainting.py

@@ -0,0 +1,244 @@
+"""Object removal via LaMa inpainting.
+
+Requires optional dependency: pip install bppicker[inpaint]
+Model (~200MB, ``big-lama.pt``) is pre-fetched via bpp's verified-
+download helper (SHA-256 pinned, 600 s timeout) and the path is
+handed to ``simple_lama_inpainting`` via the library's documented
+``LAMA_MODEL`` env-var override. The library then loads the
+already-verified file via ``torch.jit.load`` and skips its own
+``torch.hub.download_url_to_file`` (which has no SHA-256
+verification and no enforced timeout — the original integrity gap).
+
+History (kept here for the next reviewer): prior to this fix, the
+weights were fetched directly by the library and a compromised
+GitHub Releases host or MITM'd proxy could substitute different
+torch-checkpoint bytes. Torch checkpoints are pickle-based and can
+execute code at unpickling time → RCE. The
+``simple_lama_inpainting`` dep is opt-in
+(``pip install bppicker[inpaint]``), so the previous footgun was
+limited to users who'd installed that extra; still, the asymmetry
+with every other bpp model (all SHA-pinned + verified) was a real
+gap. This fix closes it.
+"""
+
+from __future__ import annotations
+
+import os
+from io import BytesIO
+
+from PIL import Image
+
+from bpp.scoring.model_base import ModelSingleton
+from bpp.utils.logging import get_logger
+from bpp.utils.paths import models_dir
+
+log = get_logger(__name__)
+
+# Upstream URL hardcoded in simple_lama_inpainting/models/model.py:7-10.
+# We fetch the same file ourselves but verify SHA-256 before letting
+# torch.jit.load see it.
+_LAMA_MODEL_URL = (
+    "https://github.com/enesmsahin/simple-lama-inpainting/releases/download/v0.1.0/big-lama.pt"
+)
+# SHA-256 of big-lama.pt at the URL above. Computed locally on
+# 2026-05-07 (size: 205,803,670 bytes). Pin both the bytes and the
+# upstream contract — if the release is ever overwritten or the URL
+# starts redirecting elsewhere, our verified-download path refuses to
+# load and the user gets a clear error rather than silent code
+# execution. Re-pin only after auditing the new upstream artifact.
+_LAMA_MODEL_SHA256 = "7ba7aa7ac37a4d41fdbbeba3a2af7ead18058552997e3a3cd1a3b2210c9e6b4c"
+_LAMA_MODEL_PATH = models_dir() / "big-lama.pt"
+
+
+def _import_check() -> None:
+    """Raise ImportError if simple_lama_inpainting is not installed."""
+    import simple_lama_inpainting  # noqa: F401
+
+
+def _create_lama(verified_path):
+    """Construct SimpleLama against an already-verified LaMa file.
+
+    By the time ``ModelSingleton`` calls this, ``ensure_model()`` has
+    either downloaded the file with SHA-256 verification or
+    re-verified an existing cached file — see
+    ``bpp.scoring.model_base.ModelSingleton.ensure_model``. We just
+    point ``simple_lama_inpainting`` at the verified path via its
+    documented ``LAMA_MODEL`` env-var override (the library's
+    ``models/model.py`` checks this env var BEFORE calling
+    ``torch.hub.download_url_to_file``, so its unsafe download path
+    never runs).
+    """
+    from simple_lama_inpainting import SimpleLama
+
+    os.environ["LAMA_MODEL"] = str(verified_path)
+    log.info("Loading LaMa inpainting model from %s", verified_path)
+    instance = SimpleLama()
+    log.info("LaMa model loaded")
+    return instance
+
+
+# Same lifecycle as every other bpp ML model: ModelSingleton checks
+# `model_path.exists() + verify SHA`, downloads if missing, calls
+# `create_fn(verified_path)`. The Settings → Advanced → ML Models
+# panel reads this registration to surface a Redownload affordance,
+# Uninstall control, and the pinned-download consent prompt before
+# the first inpaint click.
+_LAMA = ModelSingleton(
+    name="LaMa inpainting",
+    model_path=_LAMA_MODEL_PATH,
+    model_url=_LAMA_MODEL_URL,
+    model_sha256=_LAMA_MODEL_SHA256,
+    create_fn=_create_lama,
+    registry_id="lama_inpaint_research",
+    import_check=_import_check,
+)
+
+
+def is_available() -> bool:
+    """Check if inpainting dependencies are installed."""
+    return _LAMA.is_available()
+
+
+# ── Catalog-loader hooks ────────────────────────────────────────────
+#
+# LaMa is a runtime-fetched catalog entry (weights pulled on demand,
+# not listed in the download manifest). The Settings → Models picker
+# drives its Review → Download → Use → Uninstall lifecycle through
+# this trio, registered in bpp.web.bp_model_registry._catalog_loaders.
+# Mirrors the nudity / buffalo_s catalog hooks.
+
+
+def is_on_disk() -> bool:
+    """Return True if the locally-cached LaMa weight file exists.
+
+    Cheap existence check only (no SHA verify) — the picker reads it to
+    decide between "Download" and "Uninstall". A tampered cache is
+    caught and re-fetched at load time by :func:`ensure_lama_model`.
+    """
+    return _LAMA_MODEL_PATH.exists()
+
+
+def ensure_lama_model() -> str:
+    """Download + verify the LaMa weights NOW. Returns the local path.
+
+    Routes through :meth:`ModelSingleton.ensure_model`, which calls the
+    canonical :func:`bpp.utils.download.download_file` gate
+    (``registry_id="lama_inpaint_research"``) — the policy gate fires
+    BEFORE the network call, so the explicit "Download" button cannot
+    bypass license acceptance.
+    """
+    # Bracket the fetch with start/finish logs so a hang or slow
+    # download is visible in server.log (a ~200 MB file fetch was
+    # previously silent until the endpoint logged completion).
+    # ``ensure_model`` is a no-op verify when the file is already
+    # cached, so the wording stays neutral ("Ensuring"/"ready").
+    log.info("Ensuring LaMa inpainting weights (source=%s)", _LAMA_MODEL_URL)
+    path = _LAMA.ensure_model()
+    if path is None:
+        raise RuntimeError(
+            f"LaMa weights could not be downloaded "
+            f"(registry_id=lama_inpaint_research, source={_LAMA_MODEL_URL}; "
+            f"ensure_model returned None — check network access and the "
+            f"pinned upstream URL)."
+        )
+    log.info("LaMa inpainting weights ready: %s", path)
+    return str(path)
+
+
+def remove_local_weights() -> int:
+    """Delete the cached LaMa weights. Returns the bytes freed.
+
+    Backs the picker's Uninstall action and resets the in-process
+    singleton so the next load re-runs ensure → download → verify.
+    Symmetric counterpart to :func:`ensure_lama_model`. Idempotent.
+
+    A failed unlink is logged at WARNING rather than swallowed: the
+    Uninstall would otherwise report success while the 200 MB file
+    stays on disk, with no trail to diagnose why (project convention:
+    nothing should be silent).
+    """
+    freed = 0
+    if _LAMA_MODEL_PATH.exists():
+        freed = _LAMA_MODEL_PATH.stat().st_size
+        try:
+            _LAMA_MODEL_PATH.unlink()
+        except OSError:
+            freed = 0
+            log.warning(
+                "Failed to delete LaMa weights at %s",
+                _LAMA_MODEL_PATH,
+                exc_info=True,
+            )
+    tmp = _LAMA_MODEL_PATH.with_suffix(_LAMA_MODEL_PATH.suffix + ".tmp")
+    if tmp.exists():
+        try:
+            tmp.unlink()
+        except OSError:
+            log.warning("Failed to delete LaMa temp file at %s", tmp, exc_info=True)
+    _LAMA.reset()
+    return freed
+
+
+def _get_model():
+    """Return the lazily-initialised LaMa model, or None if unavailable.
+
+    Enforces the registry policy gate FIRST. LaMa weights are
+    research-only / non-commercial; the click-through acceptance
+    dialog must have been completed (with separate-rights assertion
+    in commercial mode) before the model loads. Raises
+    :class:`bpp.registry.ModelLoadBlockedError` otherwise.
+
+    Kept as a public-ish symbol because existing tests patch it directly.
+    Internally delegates to the ModelSingleton — same thread-safe lazy
+    init as every other ML model in the codebase.
+    """
+    from bpp.registry import enforce_load_policy_for
+
+    enforce_load_policy_for("lama_inpaint_research")
+    return _LAMA.get()
+
+
+def inpaint(image: Image.Image, mask: Image.Image) -> Image.Image:
+    """Remove masked area from image using LaMa inpainting.
+
+    Args:
+        image: RGB input image.
+        mask: Grayscale or binary mask. White (255) = area to remove.
+
+    Returns:
+        Inpainted RGB image (same size as input).
+
+    Raises:
+        RuntimeError: If simple-lama-inpainting is not installed.
+        ValueError: If image/mask sizes don't match.
+    """
+    if image.size != mask.size:
+        raise ValueError(f"Image size {image.size} doesn't match mask size {mask.size}")
+
+    # Ensure correct modes
+    if image.mode != "RGB":
+        image = image.convert("RGB")
+    if mask.mode != "L":
+        mask = mask.convert("L")
+
+    model = _get_model()
+    if model is None:
+        raise RuntimeError("Inpainting not available. Install with: pip install bppicker[inpaint]")
+    return model(image, mask)
+
+
+def inpaint_from_bytes(image_bytes: bytes, mask_bytes: bytes) -> bytes:
+    """Convenience: accept and return PNG bytes."""
+    # Context managers release the BytesIO-backed Image handles before
+    # inpaint() runs. convert() returns a fresh Image instance so the
+    # source handles can close at the end of each `with`.
+    with Image.open(BytesIO(image_bytes)) as img_in:
+        image = img_in.convert("RGB")
+    with Image.open(BytesIO(mask_bytes)) as mask_in:
+        mask = mask_in.convert("L")
+
+    result = inpaint(image, mask)
+
+    buf = BytesIO()
+    result.save(buf, format="PNG")
+    return buf.getvalue()

bpp/cli.py

@@ -0,0 +1,303 @@
+"""CLI entrypoint for bpp."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from bpp import APP_NAME, __version__
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="bpp",
+        description=f"{APP_NAME} — score, deduplicate, and select the best photos.",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    parser.add_argument("--seed", type=int, default=42, help="Random seed for determinism")
+    # default pulled from the config registry so a plugin
+    # override (e.g. AVIF / RAW format support) propagates without
+    # touching this argparse declaration.
+    from bpp.config import DEFAULTS
+
+    parser.add_argument(
+        "--extensions",
+        default=DEFAULTS["scan_extensions"],
+        help="Comma-separated image extensions to include (default from config: scan_extensions)",
+    )
+
+    sub = parser.add_subparsers(dest="command", help="Available commands")
+
+    # --- analyze ---
+    p_analyze = sub.add_parser("analyze", help="Scan images, extract features, compute scores")
+    p_analyze.add_argument("--input", required=True, help="Input folder of photos")
+    p_analyze.add_argument("--out", required=True, help="Working directory for cache/results")
+    p_analyze.add_argument("--config", help="Path to YAML config file")
+    p_analyze.add_argument("--max", type=int, default=0, help="Max images to process (0=all)")
+    p_analyze.add_argument("--workers", type=int, default=0, help="Parallel workers (0=auto)")
+    p_analyze.add_argument("--debug", action="store_true", help="Enable debug logging")
+    p_analyze.add_argument("--dry-run", action="store_true", help="Show what would be done")
+
+    # --- select ---
+    p_select = sub.add_parser("select", help="Select best photos from analyzed data")
+    p_select.add_argument("--workdir", required=True, help="Working directory from analyze step")
+    p_select.add_argument("--k", type=int, default=50, help="Number of photos to select")
+    p_select.add_argument("--out", required=True, help="Output directory for selected photos")
+    p_select.add_argument("--config", help="Path to YAML config file")
+    p_select.add_argument("--gallery", action="store_true", help="Generate HTML gallery")
+    p_select.add_argument("--dry-run", action="store_true", help="Show what would be done")
+    mode = p_select.add_mutually_exclusive_group()
+    mode.add_argument("--copy", action="store_const", const="copy", dest="export_mode")
+    mode.add_argument("--hardlink", action="store_const", const="hardlink", dest="export_mode")
+    mode.add_argument("--symlink", action="store_const", const="symlink", dest="export_mode")
+    p_select.set_defaults(export_mode="copy")
+
+    # --- run (one-shot) ---
+    p_run = sub.add_parser("run", help="Analyze + select in one shot")
+    p_run.add_argument("--input", required=True, help="Input folder of photos")
+    p_run.add_argument("--k", type=int, default=50, help="Number of photos to select")
+    p_run.add_argument("--out", required=True, help="Output directory for selected photos")
+    p_run.add_argument("--config", help="Path to YAML config file")
+    p_run.add_argument("--max", type=int, default=0, help="Max images to process (0=all)")
+    p_run.add_argument("--workers", type=int, default=0, help="Parallel workers (0=auto)")
+    p_run.add_argument("--gallery", action="store_true", help="Generate HTML gallery")
+    p_run.add_argument("--debug", action="store_true", help="Enable debug logging")
+    p_run.add_argument("--dry-run", action="store_true", help="Show what would be done")
+    run_mode = p_run.add_mutually_exclusive_group()
+    run_mode.add_argument("--copy", action="store_const", const="copy", dest="export_mode")
+    run_mode.add_argument("--hardlink", action="store_const", const="hardlink", dest="export_mode")
+    run_mode.add_argument("--symlink", action="store_const", const="symlink", dest="export_mode")
+    p_run.set_defaults(export_mode="copy")
+
+    # --- web ---
+    p_web = sub.add_parser("web", help="Launch interactive web UI")
+    p_web.add_argument("--input", help="Input folder of photos")
+    p_web.add_argument("--workdir", help="Working directory with existing analysis")
+    p_web.add_argument("--port", type=int, default=5001, help="Port for web server")
+    p_web.add_argument(
+        "--host",
+        default=None,
+        help="Bind address (default: 127.0.0.1). Pass 0.0.0.0 for Docker port-forwarding.",
+    )
+    p_web.add_argument("--no-browser", action="store_true", help="Don't auto-open browser")
+    p_web.add_argument("--config", help="Path to YAML config file")
+    p_web.add_argument("--debug", action="store_true", help="Enable debug logging")
+
+    # --- serve ---
+    p_serve = sub.add_parser("serve", help="Start photo management server")
+    p_serve.add_argument(
+        "--library",
+        help="Library path (default: registry's active library, or ~/Pictures/BestPhotoPicker)",
+    )
+    p_serve.add_argument(
+        "--host",
+        default=None,
+        help="Bind address. Default: 127.0.0.1 (loopback only) when LAN "
+        "sharing is OFF, 0.0.0.0 when it's ON. Pass `0.0.0.0` explicitly "
+        "to bind every interface regardless of the share toggle. The "
+        "share toggle (Settings → Share) is what gates LAN access in "
+        "the auth layer; binding loopback-only is defense-in-depth so "
+        "the service isn't even visible on port scan from a coffee-shop "
+        "Wi-Fi network. If running behind a reverse proxy (nginx, "
+        "Caddy, Docker), set BPP_TRUSTED_PROXIES to the proxy's CIDR "
+        "so X-Forwarded-For is honored for the loopback gate — see "
+        "docs/security.md.",
+    )
+    p_serve.add_argument("--port", type=int, default=5001, help="Port for web server")
+    p_serve.add_argument("--no-browser", action="store_true", help="Don't auto-open browser")
+    p_serve.add_argument("--config", help="Path to YAML config file")
+    p_serve.add_argument("--debug", action="store_true", help="Enable debug logging")
+
+    # --- demo ---
+    p_demo = sub.add_parser("demo", help="Launch demo with sample photos")
+    p_demo.add_argument("--port", type=int, default=5001, help="Port for web server")
+    p_demo.add_argument("--no-browser", action="store_true", help="Don't auto-open browser")
+    p_demo.add_argument("--keep", action="store_true", help="Keep demo library after exit")
+    p_demo.add_argument("--debug", action="store_true", help="Enable debug logging")
+
+    # --- pick (power-user one-liner) ---
+    p_pick = sub.add_parser("pick", help="One-liner: score, select, and optionally export")
+    p_pick.add_argument("library", help="Path to library directory")
+    p_pick.add_argument("--top", "-k", type=int, default=50, help="Number of photos to select")
+    p_pick.add_argument(
+        "--boost-face",
+        action="append",
+        default=[],
+        dest="boost_face",
+        help="Boost a named person (repeatable)",
+    )
+    p_pick.add_argument("--out", help="Export selected photos to this directory")
+    output_fmt = p_pick.add_mutually_exclusive_group()
+    output_fmt.add_argument("--json", action="store_true", help="Output as JSON")
+    output_fmt.add_argument("--paths-only", action="store_true", help="Output filepaths only")
+    p_pick.add_argument(
+        "--quality",
+        choices=("original", "high", "medium", "low"),
+        default="original",
+        help="Export JPEG quality preset (default: original)",
+    )
+    p_pick.add_argument("--dry-run", action="store_true", help="Show selection without exporting")
+
+    # --- db restore-backup (recovery from a bad migration) ---
+    p_model = sub.add_parser(
+        "model",
+        help=(
+            "Model registry + restricted-license acceptance (text-mode parity with the GUI dialog)"
+        ),
+    )
+    model_sub = p_model.add_subparsers(dest="model_command")
+    from bpp.commands.model import add_subparsers as _add_model_subparsers
+
+    _add_model_subparsers(model_sub)
+
+    p_db = sub.add_parser(
+        "db",
+        help="Database utilities (restore from backup, etc.)",
+    )
+    db_sub = p_db.add_subparsers(dest="db_command")
+    p_restore = db_sub.add_parser(
+        "restore-backup",
+        help="Restore the library DB from .backup (or .backup.prev)",
+        description=(
+            "Recovery path for a failed schema migration or DB "
+            "corruption. The current DB is moved aside with a "
+            "timestamped suffix; .backup is verified for integrity, "
+            "then copied into place. Use --previous to restore from "
+            ".backup.prev (the older generation) instead."
+        ),
+    )
+    p_restore.add_argument(
+        "--library",
+        required=True,
+        help="Path to the library directory (the one passed to `bpp serve --library`)",
+    )
+    p_restore.add_argument(
+        "--previous",
+        action="store_true",
+        help="Restore from .backup.prev (older snapshot) instead of .backup",
+    )
+    p_restore.add_argument(
+        "--yes",
+        action="store_true",
+        help="Skip the interactive confirmation",
+    )
+    p_restore.add_argument(
+        "--accept-stale",
+        action="store_true",
+        help=(
+            "Allow restoring from a backup older than 7 days when "
+            "combined with --yes. Without this flag, --yes refuses "
+            "stale backups so automation can't silently destroy "
+            "weeks of work."
+        ),
+    )
+    p_restore.add_argument(
+        "--force",
+        action="store_true",
+        help=(
+            "Bypass the running-server lockfile check. Use only "
+            "when you're SURE no `bpp serve` / desktop app is "
+            "running against this library — overwriting the DB "
+            "with a server attached corrupts state silently."
+        ),
+    )
+
+    return parser
+
+
+def cmd_analyze(args: argparse.Namespace) -> int:
+    """Scan images, extract features, and compute quality scores."""
+    from bpp.commands import do_analyze
+
+    return do_analyze(args)
+
+
+def cmd_select(args: argparse.Namespace) -> int:
+    """Select the best photos from previously analyzed data."""
+    from bpp.commands import do_select
+
+    return do_select(args)
+
+
+def cmd_run(args: argparse.Namespace) -> int:
+    """Analyze and select in one shot."""
+    from bpp.commands import do_run
+
+    return do_run(args)
+
+
+def cmd_web(args: argparse.Namespace) -> int:
+    """Launch the interactive web UI (alias for serve)."""
+    from bpp.commands import do_web
+
+    return do_web(args)
+
+
+def cmd_serve(args: argparse.Namespace) -> int:
+    """Start the photo management server."""
+    from bpp.commands import do_serve
+
+    return do_serve(args)
+
+
+def cmd_demo(args: argparse.Namespace) -> int:
+    """Generate sample photos and launch the web UI for a quick demo."""
+    from bpp.commands import do_demo
+
+    return do_demo(args)
+
+
+def cmd_pick(args: argparse.Namespace) -> int:
+    """One-liner: score, select, and optionally export the best photos."""
+    from bpp.commands import do_pick
+
+    return do_pick(args)
+
+
+def cmd_model(args: argparse.Namespace) -> int:
+    """Dispatch `bpp model ...` to the right sub-handler set up by
+    :func:`bpp.commands.model.add_subparsers`."""
+    func = getattr(args, "_model_func", None)
+    if func is None:
+        print(
+            "Usage: bpp model <subcommand>  (try `bpp model --help`)",
+            file=sys.stderr,
+        )
+        return 1
+    return func(args)
+
+
+def cmd_db(args: argparse.Namespace) -> int:
+    """Database utility commands (restore-backup, ...)."""
+    if args.db_command == "restore-backup":
+        from bpp.commands import do_db_restore_backup
+
+        return do_db_restore_backup(args)
+    print("Usage: bpp db <subcommand>  (try `bpp db --help`)", file=sys.stderr)
+    return 1
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if args.command is None:
+        parser.print_help()
+        return 1
+
+    dispatch = {
+        "analyze": cmd_analyze,
+        "select": cmd_select,
+        "run": cmd_run,
+        "web": cmd_web,
+        "serve": cmd_serve,
+        "demo": cmd_demo,
+        "pick": cmd_pick,
+        "model": cmd_model,
+        "db": cmd_db,
+    }
+    return dispatch[args.command](args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

bpp/commands/__init__.py

@@ -0,0 +1,42 @@
+"""High-level command implementations for the bpp CLI.
+
+This was a single 1159-LOC module until the v0.1 cleanup; now it's
+a package whose submodules each own one CLI command (or a tight
+cluster of related ones):
+
+* ``bpp.commands.analyze``  — ``do_analyze``, ``do_select``, ``do_run``
+* ``bpp.commands.serve``    — ``do_web``, ``do_serve``
+* ``bpp.commands.demo``     — ``do_demo``
+* ``bpp.commands.pick``     — ``do_pick``
+* ``bpp.commands.db_restore`` — ``do_db_restore_backup``, ``_do_restore_locked``
+
+Everything is re-exported from this package so existing call sites
+keep working unchanged:
+
+    from bpp.commands import do_serve         # still works
+    from bpp.commands import _do_restore_locked  # still works
+
+The ``bpp.cli`` argparse plumbing lazy-imports each ``do_*`` only when
+its subcommand fires, which means subcommand startup cost is bounded
+by the cost of importing one submodule, not all five.
+"""
+
+from __future__ import annotations
+
+from bpp.commands.analyze import do_analyze, do_run, do_select
+from bpp.commands.db_restore import _do_restore_locked, do_db_restore_backup
+from bpp.commands.demo import do_demo
+from bpp.commands.pick import do_pick
+from bpp.commands.serve import do_serve, do_web
+
+__all__ = [
+    "_do_restore_locked",
+    "do_analyze",
+    "do_db_restore_backup",
+    "do_demo",
+    "do_pick",
+    "do_run",
+    "do_select",
+    "do_serve",
+    "do_web",
+]