rimbisect 0.1.0__py3-none-any.whl

rimbisect/__init__.py

@@ -0,0 +1,3 @@
+"""Find the RimWorld mod, or combination of mods, behind an error by bisecting your load order."""
+
+__version__ = "0.1.0"

rimbisect/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

rimbisect/about.py

@@ -0,0 +1,109 @@
+"""Read a mod's About/About.xml.
+
+Lifted from rim-loadorder-agent's ingest/build.py (parse_about), switched to lxml with
+recover=True so the unescaped ampersands and stray tags some authors ship still parse,
+and changed to follow the game on versioned lists: a <fooByVersion><v1.6> block replaces
+<foo> for that version instead of adding to it.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from lxml import etree
+
+_PARSER = etree.XMLParser(recover=True, remove_comments=True, resolve_entities=False)
+_WORKSHOP_ID = re.compile(r"(\d{6,})")
+
+
+@dataclass(frozen=True)
+class Dependency:
+    package_id: str
+    alternatives: tuple[str, ...] = ()
+    name: str | None = None
+
+
+@dataclass
+class Mod:
+    package_id: str
+    name: str
+    folder: Path
+    workshop_id: str | None = None
+    official: bool = False
+    dependencies: list[Dependency] = field(default_factory=list)
+    load_after: list[str] = field(default_factory=list)
+    load_before: list[str] = field(default_factory=list)
+    incompatible_with: list[str] = field(default_factory=list)
+    supported_versions: list[str] = field(default_factory=list)
+
+
+def _texts(node, tag: str) -> list[str] | None:
+    el = node.find(tag)
+    if el is None:
+        return None
+    return [li.text.strip() for li in el.findall("li") if li.text and li.text.strip()]
+
+
+def _for_version(root, tag: str, version: str):
+    """The <v1.6> element under <tagByVersion>, or None."""
+    holder = root.find(tag + "ByVersion")
+    return holder.find("v" + version) if holder is not None else None
+
+
+def _id_list(root, tag: str, version: str) -> list[str]:
+    versioned = _for_version(root, tag, version)
+    if versioned is not None:
+        items = [li.text.strip() for li in versioned.findall("li") if li.text and li.text.strip()]
+    else:
+        items = _texts(root, tag) or []
+    return [item.lower() for item in items]
+
+
+def _dependencies(root, version: str) -> list[Dependency]:
+    holder = _for_version(root, "modDependencies", version)
+    if holder is None:
+        holder = root.find("modDependencies")
+    out: list[Dependency] = []
+    for li in holder.findall("li") if holder is not None else []:
+        pid = (li.findtext("packageId") or "").strip().lower()
+        if not pid:
+            continue
+        alternatives = tuple(a.lower() for a in (_texts(li, "alternativePackageIds") or []))
+        out.append(Dependency(pid, alternatives, (li.findtext("displayName") or "").strip() or None))
+    return out
+
+
+def _published_id(about_dir: Path) -> str | None:
+    try:
+        text = (about_dir / "PublishedFileId.txt").read_text(encoding="utf-8-sig", errors="replace")
+    except OSError:
+        return None
+    match = _WORKSHOP_ID.search(text)
+    return match.group(1) if match else None
+
+
+def parse_about(path: Path, version: str, workshop_id: str | None = None, official: bool = False) -> Mod | None:
+    """Parse About.xml; None when it has no packageId (the game skips those too)."""
+    root = etree.parse(str(path), _PARSER).getroot()
+    if root is None:
+        return None
+    package_id = (root.findtext("packageId") or "").strip().lower()
+    if not package_id:
+        return None
+    folder = path.parent.parent
+    if workshop_id is None:
+        workshop_id = _published_id(path.parent) or (folder.name if _WORKSHOP_ID.fullmatch(folder.name) else None)
+    return Mod(
+        package_id=package_id,
+        name=(root.findtext("name") or "").strip() or folder.name,
+        folder=folder,
+        workshop_id=workshop_id,
+        official=official,
+        dependencies=_dependencies(root, version),
+        load_after=_id_list(root, "loadAfter", version) + _id_list(root, "forceLoadAfter", version),
+        load_before=_id_list(root, "loadBefore", version) + _id_list(root, "forceLoadBefore", version),
+        incompatible_with=_id_list(root, "incompatibleWith", version),
+        supported_versions=_texts(root, "supportedVersions") or [],
+    )

rimbisect/cli.py

@@ -0,0 +1,449 @@
+"""Command line entry point."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+import re
+import shutil
+import sys
+from contextlib import contextmanager
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+
+from . import __version__, report
+from .errors import UserError
+from .install import EXE_NAME, Game, default_config_dir, find_game, process_running
+from .modlist import PROBE_FOLDER, LoadOrder, ModsConfig, folder_mtime, read_mods_config, scan_mods
+from .search import Inconclusive, Search, run_answered
+from .signature import Criterion, ErrorGroup, group_errors
+from .trial import CRASH, FAIL, PASS, GameLauncher, Trial, install_probe, remove_probe
+
+
+def log(message: str) -> None:
+    print(message, file=sys.stderr, flush=True)
+
+
+@dataclass
+class Setup:
+    game: Game
+    config_path: Path
+    config: ModsConfig
+    order: LoadOrder
+    workdir: Path
+    warnings: list[str]
+
+
+def load(args) -> Setup:
+    game = find_game(args.game)
+    config_path = (args.config or default_config_dir() / "ModsConfig.xml").expanduser().resolve()
+    if args.config and not config_path.is_file():
+        raise UserError(f"--config {args.config}: no such file")
+    config = read_mods_config(config_path)
+    warnings: list[str] = []
+    mods = scan_mods(game, warnings)
+    order = LoadOrder.build(config, mods, warnings)
+    workdir = getattr(args, "workdir", None) or Path(os.environ.get("LOCALAPPDATA", Path.home())) / "rimbisect"
+    workdir = workdir.expanduser().resolve()
+    return Setup(game, config_path, config, order, workdir, warnings)
+
+
+def _preflight(setup: Setup) -> None:
+    if process_running(EXE_NAME):
+        raise UserError("RimWorld is already running. Close it first; rimbisect starts and stops the game itself.")
+    workshop = setup.game.workshop_dir
+    if workshop and process_running("steam.exe") is False:
+        count = sum(setup.order.mods[pid].folder.parent == workshop for pid in setup.order.order)
+        if count:
+            raise UserError(f"Steam is not running, and without it the game does not load your {count} "
+                            "Workshop mods. Start Steam and run rimbisect again.")
+
+
+@contextmanager
+def _session(game: Game, launcher: GameLauncher):
+    """The probe is in the game's Mods folder for the duration; the copied Config goes afterwards."""
+    try:
+        install_probe(game)
+        yield
+    finally:
+        remove_probe(game)
+        shutil.rmtree(launcher.savedata, ignore_errors=True)
+        if (game.mods_dir / PROBE_FOLDER).exists():
+            log(f"warning: could not delete {game.mods_dir / PROBE_FOLDER}; delete it before you play")
+
+
+def _new_run(setup: Setup, args) -> tuple[Path, GameLauncher]:
+    stamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+    run_dir = setup.workdir / "runs" / stamp
+    suffix = 1
+    while run_dir.exists():
+        suffix += 1
+        run_dir = setup.workdir / "runs" / f"{stamp}-{suffix}"
+    if "=" in str(run_dir):
+        raise UserError(f"the run folder {run_dir} contains '=', which RimWorld's -savedatafolder= "
+                        "cannot take. Pick another with --workdir.")
+    try:
+        run_dir.mkdir(parents=True)
+    except OSError as exc:
+        raise UserError(f"could not create the run folder {run_dir}: {exc.strerror or exc}. "
+                        "Pick another with --workdir.") from exc
+    launcher = GameLauncher(setup.game, setup.config, run_dir, default_config_dir(),
+                            settle=args.settle, timeout=args.timeout * 60, log=log)
+    return run_dir, launcher
+
+
+def _criterion(args) -> Criterion | None:
+    if args.match_text == "" or args.match == "":
+        raise UserError("--match and --match-text need some text; an empty one matches every line")
+    if args.match_text is not None:
+        return Criterion(pattern=re.compile(re.escape(args.match_text)), label=args.match_text)
+    if args.match is not None:
+        try:
+            return Criterion(pattern=re.compile(args.match))
+        except re.error as exc:
+            raise UserError(f"--match is not a valid regular expression: {exc}; "
+                            "use --match-text to match the text as it is") from exc
+    if args.slower_than is not None:
+        return Criterion(slower_than=args.slower_than)
+    return None
+
+
+NEED_PICK = "pick one of the errors above with --pick N, or pass --match-text with a piece of it"
+
+
+def _pick(groups: list[ErrorGroup], args) -> ErrorGroup:
+    shown = groups[:30]
+    log("\nErrors logged by the full mod list, most frequent first:\n")
+    for i, group in enumerate(shown, 1):
+        log(f"  {i:>3}. {group.count:>5}x  {group.headline[:140]}")
+    if len(groups) > len(shown):
+        log(f"       ... and {len(groups) - len(shown)} rarer ones")
+    if args.pick is not None:
+        if not 1 <= args.pick <= len(groups):
+            raise UserError(f"--pick {args.pick}: pick a number between 1 and {len(groups)}")
+        return groups[args.pick - 1]
+    if not sys.stdin.isatty():
+        raise UserError(NEED_PICK)
+    while True:
+        try:
+            answer = input(f"\nWhich error should rimbisect hunt? [1-{len(shown)}] ").strip()
+        except EOFError:
+            raise UserError(NEED_PICK) from None
+        if answer.isdigit() and 1 <= int(answer) <= len(groups):
+            return groups[int(answer) - 1]
+
+
+def _keep(setup: Setup, extra: list[str]) -> set[str]:
+    keep = set(setup.order.official())
+    for entry in extra:
+        for pid in filter(None, (p.strip().lower() for p in entry.split(","))):
+            if pid not in setup.order.spelling:
+                raise UserError(f"--keep {pid}: not in the active mod list. `rimbisect mods` lists the packageIds.")
+            keep.add(pid)
+    return keep
+
+
+def _last_good_path(setup: Setup) -> Path:
+    return setup.workdir / "last-good.json"
+
+
+def _since(args) -> float | None:
+    if args.since is None:
+        return None
+    try:
+        return datetime.fromisoformat(args.since).timestamp()
+    except ValueError as exc:
+        raise UserError(f"--since takes a date like 2026-09-01 or 2026-09-01T18:30, not {args.since!r}") from exc
+
+
+def _changed(setup: Setup, candidates: list[str], args) -> tuple[list[str] | None, str | None]:
+    """Mods modified since --since or since the last passing `rimbisect check`, and which of the two."""
+    mods = setup.order.mods
+    since = _since(args)
+    if since is not None:
+        changed = [p for p in candidates if folder_mtime(mods[p].folder) > since]
+        source = f"since {args.since}"
+    else:
+        path = _last_good_path(setup)
+        if args.ignore_last_good or not path.is_file():
+            return None, None
+        try:
+            saved = json.loads(path.read_text(encoding="utf-8"))["mods"]
+            if not all(isinstance(t, (int, float)) for t in saved.values()):
+                raise ValueError("folder times are not numbers")
+        except (OSError, ValueError, KeyError, TypeError, AttributeError) as exc:
+            setup.warnings.append(f"ignored {path}: {exc}")
+            return None, None
+        # Folder times from a copy or restore can shift by a second or two.
+        changed = [p for p in candidates if p not in saved or folder_mtime(mods[p].folder) > saved[p] + 2]
+        source = "since the last good run"
+    log(f"{len(changed)} of {len(candidates)} mods changed {source}")
+    if not changed or len(changed) == len(candidates):
+        return None, None
+    return changed, source
+
+
+def _save_last_good(setup: Setup) -> Path:
+    path = _last_good_path(setup)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    data = {
+        "saved": datetime.now().isoformat(timespec="seconds"),
+        "modsConfig": str(setup.config_path),
+        "mods": {pid: folder_mtime(setup.order.mods[pid].folder) for pid in setup.order.order},
+    }
+    path.write_text(json.dumps(data, indent=1), encoding="utf-8")
+    return path
+
+
+def _baseline(launcher: GameLauncher, setup: Setup, criterion: Criterion | None, args) -> Trial:
+    """The full list; with --repeats, up to that many times until it shows the error."""
+    mods = setup.order.trial_list(setup.order.order)
+    trial = run_answered(launcher, mods, "baseline", criterion, args.crash_is_fail, log)
+    if criterion is None:
+        return trial
+    log(trial.line())
+    for _ in range(args.repeats - 1):
+        if _reproduced(trial, args):
+            break
+        trial = run_answered(launcher, mods, "baseline again", criterion, args.crash_is_fail, log)
+        log(trial.line())
+    return trial
+
+
+def _warn_not_loaded(trial: Trial, setup: Setup) -> None:
+    if trial.not_loaded:
+        names = ", ".join(setup.order.written(trial.not_loaded[:10]))
+        setup.warnings.append(f"the game did not load {len(trial.not_loaded)} of the active mods even with the "
+                              f"full list ({names}), so they are not tested")
+
+
+def _reproduced(trial: Trial, args) -> bool:
+    return trial.outcome == FAIL or (args.crash_is_fail and trial.outcome == CRASH)
+
+
+def _hunted(baseline: Trial, criterion: Criterion | None, args) -> Criterion | None:
+    """The criterion to search with, or None when the baseline did not reproduce anything."""
+    if criterion is not None:
+        return criterion if _reproduced(baseline, args) else None
+    if args.crash_is_fail and args.pick is None:
+        return Criterion() if baseline.outcome == CRASH else None
+    groups = group_errors(baseline.errors)
+    if not groups:
+        return None
+    chosen = _pick(groups, args)
+    baseline.outcome, baseline.excerpt = FAIL, chosen.example
+    return Criterion(signature=chosen.signature, label=chosen.headline)
+
+
+def _emit(data: dict, run_dir: Path, as_json: bool) -> None:
+    text = report.write(data, run_dir)
+    if as_json:
+        print(json.dumps(data, indent=2, ensure_ascii=False))
+    else:
+        print(text, end="")
+
+
+def cmd_bisect(args) -> int:
+    setup = load(args)
+    _preflight(setup)
+    keep = _keep(setup, args.keep)
+    kept = setup.order.closure(keep)
+    candidates = [pid for pid in setup.order.order if pid not in kept]
+    if not candidates:
+        raise UserError("every active mod is kept (Core, DLCs, --keep and what they need); there is nothing to search")
+    criterion = _criterion(args)
+    if args.pick is not None and criterion is not None:
+        raise UserError("--pick chooses from the errors of the full list; leave it out with --match, "
+                        "--match-text or --slower-than")
+    _since(args)
+    log(f"rimbisect {__version__}: {len(setup.order.order)} active mods, {len(candidates)} to search")
+    changed, changed_since = _changed(setup, candidates, args)
+    run_dir, launcher = _new_run(setup, args)
+    log(f"run folder {run_dir}")
+
+    fields = dict(run_dir=run_dir, game=setup.game, config_path=setup.config_path, order=setup.order,
+                  searched=len(candidates), warnings=setup.warnings, trials=launcher.trials,
+                  crash_is_fail=args.crash_is_fail, settle=args.settle, changed_since=changed_since)
+    search: Search | None = None
+    with _session(setup.game, launcher):
+        try:
+            baseline = _baseline(launcher, setup, criterion, args)
+            _warn_not_loaded(baseline, setup)
+            hunted = _hunted(baseline, criterion, args)
+            if criterion is None:
+                # Only now is it known whether the picked error counts as a failure.
+                log(baseline.line())
+            if hunted is None:
+                what = "the error" if criterion else "a crash" if args.crash_is_fail and args.pick is None else "any error"
+                setup.warnings.append(f"the full mod list did not reproduce {what} (baseline outcome {baseline.outcome})")
+                _emit(report.build(status=report.NOT_REPRODUCED, criterion=criterion, **fields), run_dir, args.json)
+                return 1
+            criterion = hunted
+            steps = math.ceil(math.log2(len(candidates))) if len(candidates) > 1 else 0
+            # Offsets measured with acceptance/simulate.py at 64, 200 and 400 mods.
+            log(f"the full list took {baseline.duration:.0f}s; expect about {steps + 3} more trials "
+                f"for a single culprit, {2 * steps + 4} for two mods that only fail together")
+            search = Search(setup.order, launcher, criterion, keep, repeats=args.repeats,
+                            crash_is_fail=args.crash_is_fail, log=log)
+            search.record(candidates, True)
+            causes = search.locate_all(candidates, changed)
+        except KeyboardInterrupt:
+            log("interrupted; the game has been closed")
+            _emit(report.build(status=report.INTERRUPTED, criterion=criterion, changed=changed,
+                               causes=search.groups if search else None,
+                               flaky=search.flaky if search else None, **fields), run_dir, args.json)
+            return 130
+        except Inconclusive as exc:
+            log(f"stopping: {exc}")
+            setup.warnings.append(f"{exc}. {exc.advice}")
+            _emit(report.build(status=report.INCONCLUSIVE, criterion=criterion, changed=changed,
+                               causes=search.groups if search else None,
+                               flaky=search.flaky if search else None, **fields), run_dir, args.json)
+            return 1
+    status = report.FOUND if causes else report.BASE_GAME_FAILS
+    _emit(report.build(status=status, criterion=criterion, causes=causes, base_fails=search.base_fails,
+                       flaky=search.flaky, changed=changed, **fields), run_dir, args.json)
+    return 0 if causes else 1
+
+
+def cmd_check(args) -> int:
+    setup = load(args)
+    _preflight(setup)
+    criterion = _criterion(args)
+    run_dir, launcher = _new_run(setup, args)
+    log(f"rimbisect {__version__}: one trial with all {len(setup.order.order)} active mods")
+    fields = dict(run_dir=run_dir, game=setup.game, config_path=setup.config_path, order=setup.order,
+                  criterion=criterion, trials=launcher.trials, settle=args.settle, warnings=setup.warnings)
+    with _session(setup.game, launcher):
+        try:
+            trial = launcher.run(setup.order.trial_list(setup.order.order), "check", criterion)
+        except KeyboardInterrupt:
+            log("interrupted; the game has been closed")
+            _emit(report.build(status=report.INTERRUPTED, **fields), run_dir, args.json)
+            return 130
+    log(trial.line())
+    _warn_not_loaded(trial, setup)
+    passed = trial.outcome == PASS
+    if passed:
+        log(f"saved this mod list as the last good one: {_save_last_good(setup)}")
+    status = report.CHECK_PASSED if passed else report.CHECK_FAILED
+    _emit(report.build(status=status, errors=group_errors(trial.errors), **fields), run_dir, args.json)
+    return 0 if passed else 1
+
+
+def cmd_mods(args) -> int:
+    setup = load(args)
+    order = setup.order
+    rows = []
+    for pid in order.order:
+        mod = order.mods[pid]
+        if mod.official:
+            source = "official"
+        else:
+            source = "workshop" if setup.game.workshop_dir and mod.folder.parent == setup.game.workshop_dir else "local"
+        rows.append({"packageId": order.spelling[pid], "name": mod.name, "source": source,
+                     "workshopId": mod.workshop_id, "folder": str(mod.folder),
+                     "dependencies": [d.package_id for d in mod.dependencies]})
+    if args.json:
+        print(json.dumps({"game": {"folder": str(setup.game.root), "version": setup.game.version},
+                          "modsConfig": str(setup.config_path), "mods": rows, "warnings": setup.warnings},
+                         indent=2, ensure_ascii=False))
+        return 0
+    print(f"{setup.game.root} ({setup.game.version})")
+    print(f"{setup.config_path}: {len(rows)} active mods\n")
+    print(f"{'#':>4}  {'packageId':<45} {'source':<9} {'workshop':<11} name")
+    for i, row in enumerate(rows, 1):
+        print(f"{i:>4}  {row['packageId']:<45} {row['source']:<9} {row['workshopId'] or '-':<11} {row['name']}")
+    if setup.warnings:
+        print(f"\n{len(setup.warnings)} warning(s):")
+        for w in setup.warnings:
+            print(f"  - {w}")
+    return 0
+
+
+def _above_zero(kind):
+    def parse(text: str):
+        try:
+            value = kind(text)
+        except ValueError:
+            raise argparse.ArgumentTypeError(f"not a {'whole ' if kind is int else ''}number: {text!r}") from None
+        if not (math.isfinite(value) and value > 0):
+            raise argparse.ArgumentTypeError(f"has to be more than 0, not {text}")
+        return value
+    return parse
+
+
+def _parser() -> argparse.ArgumentParser:
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument("--game", type=Path, metavar="PATH",
+                        help="RimWorld install folder (default: found through Steam)")
+    common.add_argument("--config", type=Path, metavar="FILE",
+                        help="ModsConfig.xml to test (default: the game's own). Only read, never written.")
+    common.add_argument("--json", action="store_true", help="print JSON instead of text")
+
+    trial_opts = argparse.ArgumentParser(add_help=False)
+    trial_opts.add_argument("--workdir", type=Path, metavar="PATH",
+                            help=r"where runs and last-good.json go (default: %%LOCALAPPDATA%%\rimbisect)")
+    what = trial_opts.add_mutually_exclusive_group()
+    what.add_argument("--match", metavar="REGEX", help="a trial fails when an error or log line matches REGEX")
+    what.add_argument("--match-text", metavar="TEXT",
+                      help="a trial fails when an error or log line contains TEXT, taken literally")
+    what.add_argument("--slower-than", type=_above_zero(float), metavar="SECONDS",
+                      help="a trial fails when the map takes longer than SECONDS to be ready")
+    trial_opts.add_argument("--settle", type=_above_zero(float), default=20, metavar="SECONDS",
+                            help="game seconds to keep the map running before quitting (default 20)")
+    trial_opts.add_argument("--timeout", type=_above_zero(float), default=20, metavar="MINUTES",
+                            help="give up on a trial after this many minutes (default 20)")
+
+    parser = argparse.ArgumentParser(
+        prog="rimbisect", description="Find the RimWorld mod, or combination of mods, behind an error.")
+    parser.add_argument("--version", action="version", version=f"rimbisect {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    what = "run the game on halves of your mod list until the culprit is found"
+    bisect = sub.add_parser("bisect", parents=[common, trial_opts], help=what, description=what)
+    bisect.add_argument("--pick", type=_above_zero(int), metavar="N",
+                        help="hunt error N from the full list's errors without asking")
+    bisect.add_argument("--keep", action="append", default=[], metavar="ID[,ID]",
+                        help="packageIds to load in every trial (Core and DLCs always are)")
+    bisect.add_argument("--since", metavar="DATE",
+                        help="first try the list without mods changed after DATE, like 2026-09-01 or 2026-09-01T18:30")
+    bisect.add_argument("--ignore-last-good", action="store_true",
+                        help="do not try the mods changed since the last good run first")
+    bisect.add_argument("--repeats", type=_above_zero(int), default=1, metavar="N",
+                        help="run a passing list up to N times before trusting it, for errors that come and go")
+    bisect.add_argument("--crash-is-fail", action="store_true",
+                        help="count a crash, an early exit or a map that fails to generate as the error")
+    bisect.set_defaults(func=cmd_bisect)
+
+    what = "run the full list once and, if it gets through, save it as the last good one"
+    check = sub.add_parser("check", parents=[common, trial_opts], help=what, description=what)
+    check.set_defaults(func=cmd_check)
+
+    what = "show the active mod list as rimbisect reads it, with warnings"
+    mods = sub.add_parser("mods", parents=[common], help=what, description=what)
+    mods.set_defaults(func=cmd_mods)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    # Redirected output would otherwise use the ANSI code page and choke on mod names.
+    for stream in (sys.stdout, sys.stderr):
+        if hasattr(stream, "reconfigure"):
+            stream.reconfigure(encoding="utf-8", errors="replace")
+    args = _parser().parse_args(argv)
+    try:
+        return args.func(args)
+    except UserError as exc:
+        print(f"rimbisect: error: {exc}", file=sys.stderr)
+        return 2
+    except KeyboardInterrupt:
+        print("rimbisect: interrupted", file=sys.stderr)
+        return 130
+
+
+if __name__ == "__main__":
+    sys.exit(main())

rimbisect/errors.py

@@ -0,0 +1,2 @@
+class UserError(Exception):
+    """A problem the user can fix; printed without a traceback."""