@event4u/agent-config 6.1.0 → 7.0.0

package/src/scripts/prediction-pool/poisson_sim.py

@@ -1,167 +0,0 @@
-#!/usr/bin/env python3
-"""Poisson tournament simulator for prediction-pool-optimizer.
-
-Honest replacement for "I simulated 10,000 runs" — this actually runs them.
-Goals per match are drawn from a Poisson whose rate comes from each team's
-attack / defence strength; group stages are round-robin, then a single-
-elimination bracket runs over the qualifiers. Aggregates advancement and
-title probabilities over N runs.
-
-It is an APPROXIMATION, stated as such: real tournament bracket pairings
-(winner-of-A vs runner-up-of-B …) are format-specific. Provide an explicit
-`bracket` (list of name pairs per round, or "auto" for a random seed) to
-control this; the default "auto" randomly seeds qualifiers and is good
-enough for outright/advancement estimates, not for exact-pairing bonus
-questions.
-
-Input JSON shape:
-{
-  "base_goals": 1.35,                       # league-average goals per side
-  "teams": { "Germany": {"att": 1.3, "def": 0.8}, ... },   # att/def multipliers (1.0 = average)
-  "groups": [ ["Germany","Scotland","Hungary","Switzerland"], ... ],
-  "advance_per_group": 2,
-  "bracket": "auto"                          # or omit; "auto" = random seed of qualifiers
-}
-
-Usage:
-  python3 scripts/prediction-pool/poisson_sim.py teams.json --runs 20000 [--seed 1]
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import math
-import random
-import sys
-from collections import defaultdict
-from pathlib import Path
-
-
-def _poisson(rate: float, rng: random.Random) -> int:
-    """Knuth's algorithm — stdlib only, no numpy."""
-    if rate <= 0:
-        return 0
-    L = math.exp(-rate)
-    k, p = 0, 1.0
-    while True:
-        k += 1
-        p *= rng.random()
-        if p <= L:
-            return k - 1
-
-
-def _rates(home: str, away: str, teams: dict, base: float) -> tuple[float, float]:
-    h, a = teams.get(home, {}), teams.get(away, {})
-    lam_h = base * h.get("att", 1.0) * a.get("def", 1.0)
-    lam_a = base * a.get("att", 1.0) * h.get("def", 1.0)
-    return lam_h, lam_a
-
-
-def _play(home: str, away: str, teams: dict, base: float, rng: random.Random,
-          allow_draw: bool = True) -> tuple[int, int]:
-    lam_h, lam_a = _rates(home, away, teams, base)
-    gh, ga = _poisson(lam_h, rng), _poisson(lam_a, rng)
-    if not allow_draw and gh == ga:
-        # extra-time / penalties proxy: edge to the stronger attack, else coin flip
-        if lam_h == lam_a:
-            return (gh + 1, ga) if rng.random() < 0.5 else (gh, ga + 1)
-        return (gh + 1, ga) if lam_h > lam_a else (gh, ga + 1)
-    return gh, ga
-
-
-def _group_table(group: list[str], teams: dict, base: float, rng: random.Random) -> list[str]:
-    pts = defaultdict(int)
-    gd = defaultdict(int)
-    gf = defaultdict(int)
-    for i in range(len(group)):
-        for j in range(i + 1, len(group)):
-            gh, ga = _play(group[i], group[j], teams, base, rng)
-            gd[group[i]] += gh - ga
-            gd[group[j]] += ga - gh
-            gf[group[i]] += gh
-            gf[group[j]] += ga
-            if gh > ga:
-                pts[group[i]] += 3
-            elif ga > gh:
-                pts[group[j]] += 3
-            else:
-                pts[group[i]] += 1
-                pts[group[j]] += 1
-    # rank: points, then goal difference, then goals for, then random tiebreak
-    return sorted(group, key=lambda t: (pts[t], gd[t], gf[t], rng.random()), reverse=True)
-
-
-def _knockout(qualifiers: list[str], teams: dict, base: float, rng: random.Random) -> str:
-    field = qualifiers[:]
-    rng.shuffle(field)
-    # pad to a power of two with byes
-    while (len(field) & (len(field) - 1)) != 0:
-        field.append(None)
-    while len(field) > 1:
-        nxt = []
-        for i in range(0, len(field), 2):
-            a, b = field[i], field[i + 1]
-            if a is None:
-                nxt.append(b)
-            elif b is None:
-                nxt.append(a)
-            else:
-                gh, ga = _play(a, b, teams, base, rng, allow_draw=False)
-                nxt.append(a if gh > ga else b)
-        field = nxt
-    return field[0]
-
-
-def simulate(cfg: dict, runs: int, seed: int | None) -> dict:
-    rng = random.Random(seed)
-    base = float(cfg.get("base_goals", 1.35))
-    teams = cfg["teams"]
-    groups = cfg.get("groups", [])
-    adv = int(cfg.get("advance_per_group", 2))
-
-    advanced = defaultdict(int)
-    champ = defaultdict(int)
-    for _ in range(runs):
-        qualifiers: list[str] = []
-        if groups:
-            for g in groups:
-                ranked = _group_table(g, teams, base, rng)
-                top = ranked[:adv]
-                qualifiers.extend(top)
-                for t in top:
-                    advanced[t] += 1
-        else:
-            qualifiers = list(teams.keys())
-        winner = _knockout(qualifiers, teams, base, rng) if len(qualifiers) > 1 else (qualifiers or [None])[0]
-        if winner is not None:
-            champ[winner] += 1
-
-    def pct(d):
-        return {t: round(100 * c / runs, 2) for t, c in sorted(d.items(), key=lambda kv: -kv[1])}
-
-    return {"runs": runs, "seed": seed, "advance_pct": pct(advanced), "title_pct": pct(champ)}
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser(description="Poisson tournament simulator (stdlib only).")
-    ap.add_argument("config", help="Path to teams/groups JSON.")
-    ap.add_argument("--runs", type=int, default=20000, help="Number of simulated tournaments.")
-    ap.add_argument("--seed", type=int, default=None, help="RNG seed for reproducibility.")
-    args = ap.parse_args()
-
-    cfg_path = Path(args.config)
-    if not cfg_path.is_file():
-        print(f"ERROR: config not found: {cfg_path}", file=sys.stderr)
-        return 2
-    cfg = json.loads(cfg_path.read_text(encoding="utf-8"))
-    if "teams" not in cfg:
-        print("ERROR: config needs a 'teams' object.", file=sys.stderr)
-        return 2
-
-    result = simulate(cfg, args.runs, args.seed)
-    print(json.dumps(result, indent=2))
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/src/scripts/prediction-pool/pool_winsim.py

@@ -1,236 +0,0 @@
-#!/usr/bin/env python3
-"""Field model + P(finish 1st) simulator for prediction-pool-optimizer.
-
-Honest operationalisation of the large-pool strategy note: in a big pool the
-target is **P(finish ahead of the whole field)**, not E(points). Maximizing EV
-makes your tip-set converge with everyone else's EV-max set, so you cannot open
-the gap you need. This script measures that — and greedily finds the few tips
-worth flipping off EV-max to manufacture upside.
-
-What it does:
-
-  1. Models the FIELD: each opponent commits one tip per match, drawn from a
-     softmax over the per-match EV table (temperature controls spread — low =
-     the crowd clusters tightly on EV-max, high = noisy). This is a model of
-     the crowd, stated as such; feed a real field distribution if you have one.
-  2. Pre-draws R outcome scenarios from the Poisson grids and pre-scores every
-     opponent once, so evaluating any of MY tip-sets is cheap.
-  3. Reports P(win) for the EV-max-everywhere baseline, then runs a greedy
-     flip search: repeatedly flip the single tip that most raises P(win),
-     reporting the EV cost and the P(win) gain per flip, up to --max-flips.
-
-The lesson it makes concrete: with small N the EV-max set already wins often
-and flips do not help (don't add variance you don't need); with large N and a
-deficit, a handful of calculated flips can lift P(win) materially at a small
-EV cost. The crossover is empirical — run it.
-
-It is an APPROXIMATION: the field is a softmax-EV model, not your real pool's
-tips, and the Poisson grids are only as good as the lambdas you feed (de-vigged
-consensus odds — see reference/odds-and-bonus.md). Outcomes and EV are exact
-for that model; the field shape is a prior.
-
-Input JSON:
-{
-  "rule": {"exact": 5, "diff": 3, "tendency": 2},
-  "participants": 120,            # field size N; opponents modelled = N-1 (capped by --max-opponents)
-  "my_lead": 0,                   # my current points minus the rival-to-beat's (negative = behind)
-  "field_temperature": 0.6,       # softmax temp for crowd spread around EV-max
-  "matches": [
-    {"match": "A", "lh": 2.0, "la": 0.7},
-    {"match": "B", "lh": 0.6, "la": 2.1}
-  ]
-}
-
-Usage:
-  python3 scripts/prediction-pool/pool_winsim.py pool.json --runs 4000 --max-flips 4 [--seed 1]
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import math
-import random
-import sys
-from pathlib import Path
-
-# Reuse the exact-score engine.
-sys.path.insert(0, str(Path(__file__).resolve().parent))
-from score_ev import ev_table, grid, _score  # noqa: E402
-
-
-def _parse_tip(s: str) -> tuple[int, int]:
-    h, a = s.split(":")
-    return int(h), int(a)
-
-
-def _flat_grid(g):
-    """Flatten a joint grid into (prob, (h,a)) pairs for sampling."""
-    flat = []
-    for h in range(len(g)):
-        for a in range(len(g[h])):
-            p = g[h][a]
-            if p > 0:
-                flat.append((p, (h, a)))
-    return flat
-
-
-def _sample_outcome(flat, rng: random.Random) -> tuple[int, int]:
-    r = rng.random()
-    acc = 0.0
-    for p, ha in flat:
-        acc += p
-        if r <= acc:
-            return ha
-    return flat[-1][1]
-
-
-def _softmax_pick(rows, temperature: float, rng: random.Random) -> tuple[int, int]:
-    """Pick a tip (h,a) from EV rows via softmax(EV / temperature)."""
-    if temperature <= 0:
-        h, a, _ = rows[0]
-        return h, a
-    top = rows[:24]  # the tail has negligible mass; cap for speed
-    mx = top[0][2]
-    weights = [math.exp((ev - mx) / temperature) for _, _, ev in top]
-    tot = sum(weights)
-    r = rng.random() * tot
-    acc = 0.0
-    for (h, a, _), w in zip(top, weights):
-        acc += w
-        if r <= acc:
-            return h, a
-    h, a, _ = top[-1]
-    return h, a
-
-
-def run(cfg: dict, runs: int, max_flips: int, max_opponents: int, top_flip: int,
-        seed: int):
-    rng = random.Random(seed)
-    rule = cfg.get("rule", {"exact": 4, "diff": 3, "tendency": 2})
-    pe, pd, pt = float(rule["exact"]), float(rule["diff"]), float(rule["tendency"])
-    n = int(cfg.get("participants", 20))
-    my_lead = float(cfg.get("my_lead", 0))
-    temp = float(cfg.get("field_temperature", 0.6))
-    matches = cfg["matches"]
-    n_opp = max(0, min(n - 1, max_opponents))
-
-    # Per match: EV table + sampling grid.
-    per = []
-    for m in matches:
-        rows, _ = ev_table(m["lh"], m["la"], pe, pd, pt, max_tip=6)
-        g = grid(m["lh"], m["la"])
-        per.append({"name": m.get("match", "?"), "rows": rows, "flat": _flat_grid(g)})
-
-    # Pre-draw R outcome scenarios (one actual scoreline per match per run).
-    scenarios = [[_sample_outcome(p["flat"], rng) for p in per] for _ in range(runs)]
-
-    # Model the field: each opponent commits a fixed tip per match (softmax-EV),
-    # then score each opponent across all scenarios. Keep the per-scenario field
-    # MAX so any of my tip-sets can be evaluated against it cheaply.
-    field_max = [(-1e9) for _ in range(runs)]
-    for _ in range(n_opp):
-        opp_tips = [_softmax_pick(p["rows"], temp, rng) for p in per]
-        for s_idx, sc in enumerate(scenarios):
-            tot = 0.0
-            for (th, ta), (ah, aa) in zip(opp_tips, sc):
-                tot += _score(th, ta, ah, aa, pe, pd, pt)
-            if tot > field_max[s_idx]:
-                field_max[s_idx] = tot
-
-    def my_total(tipset, s_idx):
-        sc = scenarios[s_idx]
-        tot = 0.0
-        for (th, ta), (ah, aa) in zip(tipset, sc):
-            tot += _score(th, ta, ah, aa, pe, pd, pt)
-        return tot
-
-    def p_win(tipset):
-        wins = 0
-        for s_idx in range(runs):
-            if my_total(tipset, s_idx) + my_lead > field_max[s_idx]:
-                wins += 1
-        return wins / runs
-
-    # Baseline: EV-max on every match.
-    ev_max_set = [(p["rows"][0][0], p["rows"][0][1]) for p in per]
-    base_pwin = p_win(ev_max_set)
-
-    # Greedy flips: repeatedly flip the one tip that most raises P(win),
-    # considering each match's top-`top_flip` EV candidates.
-    current = list(ev_max_set)
-    flips = []
-    used = set()
-    for _ in range(max_flips):
-        best = None
-        for mi, p in enumerate(per):
-            if mi in used:
-                continue
-            for h, a, ev in p["rows"][:top_flip]:
-                if (h, a) == current[mi]:
-                    continue
-                trial = list(current)
-                trial[mi] = (h, a)
-                pw = p_win(trial)
-                ev_cost = p["rows"][0][2] - ev
-                if best is None or pw > best["pwin"]:
-                    best = {"mi": mi, "tip": (h, a), "pwin": pw, "ev_cost": ev_cost,
-                            "name": p["name"]}
-        if best is None or best["pwin"] <= (flips[-1]["pwin"] if flips else base_pwin):
-            break
-        current[best["mi"]] = best["tip"]
-        used.add(best["mi"])
-        flips.append(best)
-
-    return {
-        "participants": n, "opponents_modelled": n_opp, "runs": runs,
-        "my_lead": my_lead, "field_temperature": temp,
-        "rule": {"exact": pe, "diff": pd, "tendency": pt},
-        "ev_max_set": [f"{per[i]['name']}={h}:{a}" for i, (h, a) in enumerate(ev_max_set)],
-        "p_win_ev_max": round(base_pwin, 4),
-        "flips": [
-            {"match": f["name"], "to": f"{f['tip'][0]}:{f['tip'][1]}",
-             "ev_cost": round(f["ev_cost"], 3), "p_win_after": round(f["pwin"], 4)}
-            for f in flips
-        ],
-        "p_win_after_flips": round((flips[-1]["pwin"] if flips else base_pwin), 4),
-    }
-
-
-def main(argv=None) -> int:
-    ap = argparse.ArgumentParser(description="Field model + P(win) simulator.")
-    ap.add_argument("config", help="JSON config (rule, participants, my_lead, matches)")
-    ap.add_argument("--runs", type=int, default=4000, help="outcome scenarios (default 4000)")
-    ap.add_argument("--max-flips", type=int, default=4, help="max tips to flip off EV-max")
-    ap.add_argument("--max-opponents", type=int, default=300,
-                    help="cap opponents modelled (default 300)")
-    ap.add_argument("--top-flip", type=int, default=4,
-                    help="EV candidates per match to consider when flipping")
-    ap.add_argument("--seed", type=int, default=1)
-    ap.add_argument("--json", action="store_true", help="emit JSON instead of text")
-    args = ap.parse_args(argv)
-
-    cfg = json.loads(Path(args.config).read_text())
-    res = run(cfg, args.runs, args.max_flips, args.max_opponents, args.top_flip, args.seed)
-
-    if args.json:
-        print(json.dumps(res, indent=2))
-        return 0
-
-    print(f"participants {res['participants']} (modelled {res['opponents_modelled']})  "
-          f"runs {res['runs']}  my_lead {res['my_lead']}  field_temp {res['field_temperature']}")
-    print(f"EV-max set: {', '.join(res['ev_max_set'])}")
-    print(f"P(win) all-EV-max : {res['p_win_ev_max']:.4f}")
-    if not res["flips"]:
-        print("greedy flips: none improved P(win) — EV-max is already best (small/easy field).")
-    else:
-        print("suggested flips (greedy, each raises P(win) most):")
-        for f in res["flips"]:
-            print(f"  flip {f['match']} -> {f['to']}  (EV cost {f['ev_cost']:+.3f})  "
-                  f"P(win) {f['p_win_after']:.4f}")
-        print(f"P(win) after flips: {res['p_win_after_flips']:.4f}  "
-              f"(+{res['p_win_after_flips'] - res['p_win_ev_max']:.4f})")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/src/scripts/prediction-pool/score_ev.py

@@ -1,188 +0,0 @@
-#!/usr/bin/env python3
-"""Exact-score EV optimiser for prediction-pool-optimizer.
-
-Honest replacement for eyeballing the favourite — given each side's expected
-goals (lambda) and the pool's scoring rule, this builds the full Poisson
-score grid and computes the expected points of EVERY candidate tip, then
-prints the EV-maximizing scoreline. It exists to kill two recurring failure
-modes:
-
-  1. Hallucinated high scorelines (4:2, 1:4, 3:2 ...). Under any partial-points
-     rule these are almost never EV-max for a moderate favourite — the points
-     live in the tendency and goal-difference tiers, not the exact high score.
-  2. Under-tipped draws. A correctly-tipped draw banks the goal-difference
-     tier on every draw scoreline, so a 1:1 can beat a 1:0 in a close game.
-     The grid surfaces this; intuition does not.
-
-The scoring model (configurable points per tier):
-
-    exact result  → --exact     (default 4)
-    goal diff      → --diff      (default 3)   # same difference, not exact; draw-on-draw lands here
-    tendency       → --tendency  (default 2)   # same W/D/L sign only
-    else           → 0
-
-For kicktipp's common "2 / 3 / 5" config run with --tendency 2 --diff 3 --exact 5.
-
-It is an APPROXIMATION only in its goal model: a Poisson per side with the
-provided lambdas, sides independent. That is the standard football scoreline
-model and is robust to small lambda changes — but the lambdas themselves must
-come from de-vigged consensus odds (see reference/odds-and-bonus.md), not a
-guess. Feed it real numbers and the EV-max is exact for that model.
-
-Input — either two lambdas on the CLI:
-
-  python3 scripts/prediction-pool/score_ev.py --lh 2.0 --la 0.7
-  python3 scripts/prediction-pool/score_ev.py --lh 0.6 --la 2.1 --tendency 2 --diff 3 --exact 5
-
-or a JSON file of named matches (batch):
-
-  python3 scripts/prediction-pool/score_ev.py matches.json --tendency 2 --diff 3 --exact 5
-
-  matches.json:
-  [
-    {"match": "Senegal-Iraq",  "lh": 2.0, "la": 0.7},
-    {"match": "Qatar-Switzerland", "lh": 0.6, "la": 2.1}
-  ]
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import math
-import sys
-from pathlib import Path
-
-MAX_GOALS = 12  # truncation of the Poisson grid; tail beyond this is negligible
-
-
-def _pois_pmf(k: int, rate: float) -> float:
-    if rate <= 0:
-        return 1.0 if k == 0 else 0.0
-    return math.exp(-rate) * rate ** k / math.factorial(k)
-
-
-def _sign(x: int) -> int:
-    return (x > 0) - (x < 0)
-
-
-def _score(th: int, ta: int, ah: int, aa: int,
-           pts_exact: float, pts_diff: float, pts_tend: float) -> float:
-    """Points a tip (th:ta) earns against an actual result (ah:aa)."""
-    if th == ah and ta == aa:
-        return pts_exact
-    if (th - ta) == (ah - aa):
-        return pts_diff
-    if _sign(th - ta) == _sign(ah - aa):
-        return pts_tend
-    return 0.0
-
-
-def grid(lh: float, la: float, max_goals: int = MAX_GOALS):
-    """Joint probability of every actual scoreline up to max_goals."""
-    ph = [_pois_pmf(k, lh) for k in range(max_goals + 1)]
-    pa = [_pois_pmf(k, la) for k in range(max_goals + 1)]
-    return [[ph[h] * pa[a] for a in range(max_goals + 1)] for h in range(max_goals + 1)]
-
-
-def ev_table(lh: float, la: float, pts_exact: float, pts_diff: float, pts_tend: float,
-             max_tip: int = 6, max_goals: int = MAX_GOALS):
-    """EV (expected points) of every candidate tip up to max_tip goals/side."""
-    g = grid(lh, la, max_goals)
-    rows = []
-    for th in range(max_tip + 1):
-        for ta in range(max_tip + 1):
-            ev = 0.0
-            for ah in range(max_goals + 1):
-                for aa in range(max_goals + 1):
-                    p = g[ah][aa]
-                    if p <= 0:
-                        continue
-                    s = _score(th, ta, ah, aa, pts_exact, pts_diff, pts_tend)
-                    if s:
-                        ev += p * s
-            rows.append((th, ta, ev))
-    rows.sort(key=lambda r: r[2], reverse=True)
-    return rows, g
-
-
-def _modal(g) -> tuple[int, int, float]:
-    best = (0, 0, 0.0)
-    for h in range(len(g)):
-        for a in range(len(g[h])):
-            if g[h][a] > best[2]:
-                best = (h, a, g[h][a])
-    return best
-
-
-def _p_draw(g) -> float:
-    return sum(g[i][i] for i in range(len(g)))
-
-
-def analyse(lh: float, la: float, pts_exact: float, pts_diff: float, pts_tend: float,
-            max_tip: int = 6, top: int = 6):
-    rows, g = ev_table(lh, la, pts_exact, pts_diff, pts_tend, max_tip)
-    mh, ma, mp = _modal(g)
-    return {
-        "lambda": [lh, la],
-        "rule": {"exact": pts_exact, "diff": pts_diff, "tendency": pts_tend},
-        "ev_max": {"tip": f"{rows[0][0]}:{rows[0][1]}", "ev": round(rows[0][2], 3)},
-        "modal_result": {"score": f"{mh}:{ma}", "prob": round(mp, 3)},
-        "p_draw": round(_p_draw(g), 3),
-        "ranked": [{"tip": f"{h}:{a}", "ev": round(ev, 3)} for h, a, ev in rows[:top]],
-    }
-
-
-def _print_one(name: str | None, res: dict) -> None:
-    if name:
-        print(f"\n## {name}")
-    lh, la = res["lambda"]
-    r = res["rule"]
-    print(f"lambda {lh}:{la}  rule exact={r['exact']} diff={r['diff']} tendency={r['tendency']}")
-    print(f"EV-max tip : {res['ev_max']['tip']}  (EV {res['ev_max']['ev']})")
-    print(f"modal score: {res['modal_result']['score']}  (P {res['modal_result']['prob']})  "
-          f"P(draw) {res['p_draw']}")
-    print("ranked by EV:")
-    for row in res["ranked"]:
-        flag = "  <- EV-max" if row["tip"] == res["ev_max"]["tip"] else ""
-        print(f"  {row['tip']:>5}  EV {row['ev']:.3f}{flag}")
-
-
-def main(argv=None) -> int:
-    ap = argparse.ArgumentParser(description="Exact-score EV optimiser (Poisson grid).")
-    ap.add_argument("matches", nargs="?", help="JSON file of matches [{match,lh,la}]")
-    ap.add_argument("--lh", type=float, help="home expected goals (lambda)")
-    ap.add_argument("--la", type=float, help="away expected goals (lambda)")
-    ap.add_argument("--exact", type=float, default=4.0, help="points for exact result (default 4)")
-    ap.add_argument("--diff", type=float, default=3.0, help="points for correct goal difference (default 3)")
-    ap.add_argument("--tendency", type=float, default=2.0, help="points for correct tendency (default 2)")
-    ap.add_argument("--max-tip", type=int, default=6, help="max goals/side to consider as a tip")
-    ap.add_argument("--top", type=int, default=6, help="rows to print per match")
-    ap.add_argument("--json", action="store_true", help="emit JSON instead of text")
-    args = ap.parse_args(argv)
-
-    jobs: list[tuple[str | None, float, float]] = []
-    if args.matches:
-        data = json.loads(Path(args.matches).read_text())
-        for m in data:
-            jobs.append((m.get("match"), float(m["lh"]), float(m["la"])))
-    elif args.lh is not None and args.la is not None:
-        jobs.append((None, args.lh, args.la))
-    else:
-        ap.error("provide either a matches JSON file or --lh and --la")
-
-    out = []
-    for name, lh, la in jobs:
-        res = analyse(lh, la, args.exact, args.diff, args.tendency, args.max_tip, args.top)
-        if name:
-            res["match"] = name
-        out.append(res)
-        if not args.json:
-            _print_one(name, res)
-
-    if args.json:
-        print(json.dumps(out, indent=2))
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())